本文共 10579 字，大约阅读时间需要 35 分钟。

安装上了Java环境，我们就可以开始Java的学习了。首先学习一些基础知识，为Java学习打好地基！

第二周：Java基础

一、学会起名字（Java中的标识符）

给类、接口、方法、包等起名字的字符序列；标识符的组成规则：

        1）英文字母（包含大小写）；

        2）数字字符；

        3)$与_ ；       //注意：不能以数字字符开头

1）给包起名

规则：字母全部都小写

    单级包：javastudy

    多级包：org.java_name        //tips：常采用域名反写的方式给包命名

2）给类、接口起名：

规则：单个单词：第一个字母大写：class Java

          多个单词：每个单词的首字母大写：class JavaStudy

3）给方法（函数）起名：    //C语言面向过程的语言中称为函数，Java面向对象的语言中一般称作方法

规则：单个单词：字母全部都小写：public static void function（）

          多个单词：第一个单词全部小写，从第二个单词开始每个单词首字母大写：public static void functionTest（）

4）给常量起名：

规则：单个单词：字幕全部大写：JAVA

          多个单词：字母全部大写，单词直接用下划线隔开：JAVA_STUDY

二、了解关键字

关键字：关键字是Java中具有特殊含义的字符序列（单词），是程序的重要组成部分。Java不允许对关键字赋予别的含义。所有的关键字都是小写的，如果被大写就不是关键字了。

常用的几个：

class：Java中被赋予特定含义的单词

public：权限修饰符：公开的

private：私有的

a.定义数据类型的关键字：byte、short、int、long、float、double、char、boolean；

b.流程控制的关键字：if···else、switch、case、default、do···while、for、break、continue；

c.方法、类型、变量的修饰关键字：private、public、protected、final、static、abstract、synchronized、volatile；

d.异常处理关键字：try、catch、finally、throw、throws；

e.对象相关关键字：new、extends、implements、class、instanceof、this、super；

f.字面常量关键字：false、true、null:

g.方法相关关键字：return、void；

h：包相关关键字：package、import；

Java中的几种注释方法：

a-->单行注释：//

b-->多行注释：/*  内容  */

c-->文档注释：/**   内容  */

简单了解一下结构：

public class Hello{        //class表示这是类 Hello是类名

public static void main(String[ ]args){        //这是一个主方法

System.out.println("HelloWorld!");        //这是一个输出语句的固定格式 }

}

三、常量与变量

常量：Java中的常量定义和变量基本相同，在类型前面加修饰符final关键字即可。

        final int MAX_NUM=100;        //注意命名规则，全部大写，单词之间用下划线_隔开；常量一般定义之后不再修改！

    1)字面值常量：

    a.字符串常量：用双引号括起来的内容：“hello”；

    b.字符常量：用单引号括起来的内容：‘A’、‘b’、‘0’ //‘ab’单引号里面有多个字符是错误的

    c.整数常量：100、1000；

    d.小数常量：3.1415；

    e.布尔（boolean）常量：true、false；

    f.空常量：null(在讲面向对象的时候,如果一个对象为null,那么一定要给对象进行非空判断)

   // 2）自定义常量    //继承学了之后补充

变量：变量是Java中的基本存储单元，值可以被修改；

变量三要素：1）数据类型；2）变量名；3）初始化值；

 数据类型的分类

      1）基本数据类型:4类8中

       整数类型:     (整数类型默认int类型) 占用的字节数             范围          byte  :字节类型                  1     -128~127          short :短整型                                2                  -2^15~2^15-1           int   :整数类型         4                  -2^31~2^31-1              long  :长整型            8                  -2^63~2^63-1       浮点类型:     (浮点类型默认double类型)           float :单精度         4                   3.4e-038~3.4e+038            double:双精度 8                   1.7e-308~1.7e+308       字符类型：   char         2

      布尔类型：   boolean(true/false)         1

//定义long类型的变量:由于整数类型默认是int类型 ,所有在long类型变量值后面加上一个标记:L或者l ,建议使用L

//float  :浮点类型默认是double类型,float类型加标记:F或者f,建议使用F

注意事项：

                1)定义变量,不能是Java中的关键字；

   2)不能是以数字开头；

   3)一个变量名不能重复定义；

                4)建议:一行定义一个变量；

数据类型转换：各种数据类型的数据可以在一起进行混合运算。运算时，不同类型的数据先转换为相同类型的数据再进行运算。数据类型之间的转换分为自动类型转换和强制类型转换两种；

自动类型转换：从低级到高级发生自动类型转换，也就是从表示范围小的类型向表示范围大的类型发生自动类型转换；

                    低-----------------------------------------------高

                    byte、short、char->int->long->float->double

在进行变量计算的时候  :尽量同一个的数据类型之间进行换算

不同类型之间的数据:数据类型的默认提示

byte,short,char 三个之间相互不转换的,但是一旦参与运算,都默认转换转换成int类型

强制类型转换: 目标数据类型   变量名 = (目标数据类型)(变量值);

例题：

byte b1=3,b2=4,b;

b=b1+b2;b=3+4;哪句是编译失败的呢？为什么呢？ b=b1+b2;编译失败:  byte,short,char之间相互不转换,一旦进行运算的,默认提升为一个int类型         变量相加,是先看数据类型,最终相加后的结果是否在当前这个类型范围之内 b=3+4; 编译正确:   常量相加,是运算,看当前结果是否在范围之内!

    2）引用数据类型        //数组学了之后补充

四、运算符

java中用到的运算符：算数运算符、赋值运算符、比较运算符、逻辑运算符、三目运算符；

1）算数运算符

二元：+、-、*、/（取得是整数）、%（去摸：取余数）    //二元运算符，运算结果的数据类型一般为操作数中表达范围大的；

一元：+、-、++、--        //一元运算符，远算结果的类型和操作数的类型相同；

java中对‘+’运算进行了扩展：

a.可以作为运算符； b.表示一个数是正整数； c.可以作为字符串的拼接符；

扩展的算术运算符:

  ++或者--  单独使用：结论:无论++或者--再数据前还是数据后,都是自增1或者自减1     参与运算使用: 结论：如果++或者--在数据的前面,先自增或者自减,再参与运算

             如果++或者--在数据的后面,先运算,再进行自增或者自减  

//在实际开发中,++在后用的多(比如:流程空语句 for循环语句 步长语句变量名++)

例题：请分别计算出a,b,c的值

int a=10;

int b=10;int c=10;a=b++;        //a=10,b=11, c=10c=--a;        // a=9, b=11,c=9b=++a;    //a=10,b=10,c=9

a=c--;    //a=9,  b=10,c=8

2）赋值运算符

基本的赋值运算符：=

举例：int a=10； 将10赋值给int类型的变量a；

扩展的赋值运算符：+=、-=、*=、/=、%=；

举例：y+=10; 相当于 y=y+10；

          a*=b+5;相当于 a=a*(b+5); 因为赋值运算符的优先级最低；

//变量的定义,1)直接去初始化值 2)如果是声明了,但是没有赋值,那么在使用之前必须给它进行赋值,否则会报错；

可以一行给多个变量赋值：a=b=10;

例题:short s=1;

s = s+1;     //有问题：1为int类型，s默认类型提升,提升为int类型,,不能用short类型的s去接收int类型的数据 , short s=1;

s+=1;        //等价于: s = (s)(s+1) ;

扩展的赋值运算符隐藏了强制类型转换!

上面两个代码有没有问题，如果有，那里有问题。

3)关系（比较）运算符

关系运算符用来比较两个值之间的大小，结果返回布尔值：true或false；

共有6种：>、>=、<、<=、!=、==    //==不能写成=！！  

4）逻辑运算符

基本逻辑运算符：&（逻辑与）、|（逻辑或）、^（逻辑异或）、！（逻辑非）

逻辑&：有false则false；

逻辑|：有true则true；

逻辑^：相同则为false，不同则true；

逻辑！：非true则false，非false则true，双！则为它本身；

扩展的逻辑运算符：||（逻辑双与）、&&（逻辑双或）

a:共同点:效果是一样的

b:逻辑双与&& ,如果左边的表达式如果是false,那么右边不执行(具有短路效果)；    //实际开发中较为常用

   逻辑双或|| :如果左边的表达式是true,那么右边不执行(具有短路效果)；

5）三目（条件）运算符

格式：（表达式）？true的结果：false的结果；

举例：int a = 10 ;

  int b = 20 ;

int max = (a >b) ? a :b ;

五、键盘录入

由于之前的变量与运算符值都是写死的，程序操作不灵活，所以提前学习键盘录入

步骤:

  1)创建一个键盘录入对象  Scanner scanner = new Scanner(System.in) ;    2)由于java.lang.* 包不是不用导包的,但是Scanner它是java.util.Scanner  导包: import java.util.Scanner;    3)接收键盘录入的数据(以int类型为例)  int number = sc.nextInt() ;  nextXXX() ;     //接收字符串的方式String num = sc.nextLine() ;

  4)输出数据

六、表达式

1）表达式是程序设计语言的基本组成部分，表示一种求值的规则，是由运算符和操作数组成的符号序列。表达式根据运算符的优先级别和结合性，首先执行指定的计算，再返回某个值。 

2）表达式的运算结果的类型就是表达式的类型。表达式一般用来给变量赋值，以及在程序中作为控制条件。在表达式中使用的变量必须已经被初始化。

3）如果把一个表达式赋值给某个变量，同样需要进行类型检查，如果两边类型不同，则需要进行强制或自动类型转换。

4）一个变量或者变量名是最简单的表达式，其值就是该常量或变量的值。

5）在对表达式进行运算时，遵循一定的规则，要按运算符的优先级从高到底进行，同级的运算符则按从左到右的方向进行。

运算符的优先级：

结论：//为了使表达式的结构更清楚可以使用（ ）表明运算次序；

 a.赋值运算符的优先级最低，因为赋值运算符要使用表达式的值。                                                                                           b.关系运算符的优先级比逻辑运算符的优先级高。                                                                                                                 c.一元运算符的优先级也比较高。                                                                                                                                            d.算数运算符要比关系运算符和二元逻辑运算符的优先级要高。

七、程序（流程）控制语句

Java程序控制语句分为3种：选择、循环、跳转；

1）选择语句根据条件表达式计算结果，并使程序可以选择不同的执行路径；

2）循环语句使程序能够重复执行一个或多个语句；

3）跳转语句允许程序以非线性的方式执行；

1.选择结构语句之 if 语句

if语句有三种格式：    

1）第一种：

if（条件表达式）{        //条件表达式无论简单复杂，它的值都是boolean类型

                语句；

}

执行流程：如果表达式成立，那么执行括号中的语句，否则不执行；

适合单个条件的判断；

2）第二种：

if(条件表达式){   

语句1;   }else{   语句2;

  }

执行流程：判断条件表达式是否成立，成立则执行语句1；否则执行语句2；

3）第三种：

if(条件表达式1){

语句1; }else if(条件表达式2){ 语句2; }else if(..){ 语句3; }else{ 语句n+1;

}

执行流程:先判断条件表达式1是否成立-->成立,则执行语句1

              不成立,判断条件表达式2是否成立-->成立,执行语句2

...

如果都不成立,最终执行else中的语句

if语句的注意事项:

   1)if语句中的大括号,可以省略,但是不建议省略   2)有大括号的地方不能有分号,有分号的地方不能有大括号!

   3)这种格式的if语句,适合单个条件的判断

2.选择结构语句之 switch 语句

语句格式：

switch(表达式){

  case 值1:  语句1;   break ; case 值2: 语句2; break; case 值3: 语句3; break;      .... default: 语句n+1; break;  }

执行流程:

        case语句中的值1和表达式中的值比较,如果一致,执行语句1        如果不一致,走case 值2,再进行比较,如果一致,执行语句2           ....

        如果上述都不一致,执行default中的语句；

 格式的解释:

        switch:当前是一个选择结构语句,它的作用和if语句是一样        case语句:它后面的值是和表达式进行比较  break:表示结束当前switch语句

        default:是和if语句中的else意识时候一样的,如果条件都不成立,执行default中的语句

 switch语句中的表达式能跟的类型:

                        byte,short,int,char

    jdk5以后,可以跟枚举

    jdk7以后,可以String类型

switch语句中的注意事项:

  1)case语句的后面只能跟常量(根据具体的需求),不能跟变量!   //javascript中的case后面是可以跟变量并且还可以是表达式  2)default语句可以在switch语句中的任何位置,不影响代码执行,如果是在语句中间,那么break最好带上  3)建议把break带上,否则会造成一个现象:case穿透!  4)switch语句的结束条件:  a.语句break语句结束

  b.执行默认执行到末尾语句结束  5)case语句的后面是冒号（:）,表示和switch语句中的表达式进行比较

  6)跳转控制语句: break,continue,retrun

两个例题：看程序写结果

int x = 2 ;

int y = 3 ;    switch(x) { default: y++; break ; case 3: y++ ; case 4: y++; }

y的值为多少？    //y=4；因为switch语句的结束条件: 1)语句break结束,2)程序默认执行的末尾

int a =2 ;

int b = 3 ; switch(a) { default : b++ ;    //4 case 3: b++ ;    //5 case 4: b++;    //6

}

b的值为多少？    //b=6；同样因为switch语句的结束条件为遇break结束或程序默认执行的末尾；

case穿透实例：

System.out.println("请你输入月份的值:");		int month = sc.nextInt() ;				//使用switch语句进行判断        	switch(month) {		case 1:			System.out.println("冬季");			break ;		case 2:			System.out.println("冬季");			break ;		case 3:			System.out.println("春季");			break ;		case 4:			System.out.println("春季");			break ;		case 5 :			System.out.println("春季");			break ;		case 6:			System.out.println("夏季");			break ;		case 7:			System.out.println("夏季");			break ;		case 8:			System.out.println("夏季");			break ;		case 9:			System.out.println("秋季");			break ;		case 10 :			System.out.println("秋季");			break ;		case 11 :			System.out.println("秋季");			break ;		case 12:			System.out.println("冬季");			break ;		default:			System.out.println("没有该月份...");			break ;		}		/**		 * 上述代码非常麻烦:优化改进		 * 利用的case穿透		 */		switch(month) {		case 1:		case 2:		case 12:			System.out.println("冬季");			break ;		case 3:		case 4:		case 5:			System.out.println("春季");			break ;		case 6:		case 7:		case 8:			System.out.println("夏季");			break;		case 9:		case 10:		case 11:			System.out.println("秋季");			break ;		default:			System.out.println("没有该月份...");			break ;		}

3.循环结构语句之 for 语句

语句结构：

for(初始化语句;条件语句;步长语句){

  循环体语句;   }

执行流程:

  初始化语句:给当前变量进行赋值,如果满足条件语句,那么执行循环体语句  执行步长语句,对变量进行自增或自减---->在对条件语句进行判断,如果满足条件,再次执行循环体---->步长语句

  直到不满足条件为止,循环语句结束...

注意事项:

  1)条件语句,不管是一个简单的表达式还是复杂的表达式,都是boolean类型

  2)初始化语句和条件表语句后面都要带上分号;

例题：

简单求和：

int sum = 0 ;

for(int x =1 ; x <= 10 ; x ++) { //sum和变量x进行求和 sum += x ; }

System.out.println("1-10之间的和是:"+sum);

求偶数和：

//需求:求1~100之间的偶数和		//方式1:		int sum = 0;		for(int x = 1 ; x <=100 ; x ++) {			//可以判断:如果能够被2整除			if(x%2==0) {				sum +=x ;			}		}		System.out.println("1~100之间的偶数和是:"+sum);		//方式2：		int sum= 0  ;		for(int x = 0 ; x <=100 ; x +=2 ) {			sum+=x ;		}		System.out.println("1~100之间的偶数和是:"+sum);	}

输出水仙花数：

public class ShuiXianHuaShu {		public static void main(String[] args) {		//定义一个统计变量		int count=0；		//建立for循环遍历水仙花数		for(int x = 100 ; x < 1000; x ++) {						//获取每个位上的数据			//个			int ge = x %10 ;			//十			int shi = x /10 %10 ;			//百			int bai = x /10 /10 %10 ;			//满足条件就输出			if(x==(ge*ge*ge+shi*shi*shi+bai*bai*bai)) {				count++；	//满足条件统计数自增一次				System.out.println("所有的水仙花数是:"+x);			}		}		System.out.println("水仙花数共有 "+count+"个");	}}

3.1 forfor 循环嵌套

可以利用 for 循环中嵌套 for 循环输出一些阵列

举例：

输出4行5列的 *

   *****   *****   *****

   *****

for(int x = 0 ; x <4; x ++) {//控制行数			for(int y = 0 ;y<5; y ++) {//控制列数				System.out.print("*");			}			System.out.println(); //换行		}

输出下列的形状 * ** *** ****

*****

for(int x = 0 ; x < 5 ; x ++) {//行			for(int y = 0 ;y<=x ; y++) {//列				System.out.print("*");			}			System.out.println();					}

99乘法表

for(int x = 1 ; x <= 9 ; x ++) {//行数			for(int y = 1 ; y <=x ; y ++) {//列数				System.out.print(y+"*"+x+"="+(y*x)+"\t");			}			System.out.println();		}

4.循环结构语句之 while 循环

格式:

    基本格式:    while(条件表达式){     循环语句体;

    }

扩展格式:(优于基本格式)

      初始化语句 ;      while(条件表达式){       循环体语句;      步长语句;

      }

执行流程:

初始化语句对变量进行赋值,如果满足条件表达式,那么执行循环体语句,执行步长语句---->继续判断是否满足条件--->满足条件,继续执行循环体语句,步长语句---->当满足不足条件为止结束

实例：

while 语句实现水仙花数

//3位数

int x = 100 ; while(x<1000) { //获取每个位上的数据 int ge = x%10 ; int shi = x /10 %10; int bai = x/10/10 %10; if(x==(ge*ge*ge+shi*shi*shi+bai*bai*bai)) { System.out.println(x); } x ++ ;

}

4.1while循环和for循环的区别?

  1)如果从内存角度考虑,for循环要优于while循环,for循环语句执行完毕之后,变量会及时被GC垃圾回收器回收掉   while循环,它可以去访问循环语句中的变量   2)根据具体需求具体分析,   如果循环次数明确的情况下,应用for循环  

  如果不知道要循环多少次,应该去使用while循环

5.循环结构语句之 do-while 语句

基本格式

  do{   循环体语句  }whiel(判断条件语句) ; 扩展格式:  初始化语句;  do{   循环体语句;  控制体语句;(步长语句)

  }while(条件判断语句) ;

do-while和前两者之间最大的区别:循环体语句至少执行一次

实际开发:优先考虑 for循环,其次while循环,最后,do-while

6.跳转控制语句

break:表示中断,结束的意思,结束语句;不能单独使用,一般在switch、for等循环(loop)语句中起跳出当前循环的作用

实例：

for(int i=0;i<10;i++) {

System.out.println("i="+i); if(i==5) { System.out.println("已跳出循环");//验证i=5时可以跳出循环 break; }

}

//实例效果

i=0

i=1i=2i=3i=4i=5已跳出循环

continue:继续的意思,跳出当前循环,直接进入一次循环；有时需要强迫一次循环提前结束从而进行下一次循环，

也就是可以继续运行循环，但是要忽略这次循环剩余的循环体的语句，这时要用到continue语句；continue不能单独使用，常用于循环语句

实例：

for(int i=1;i<=20;i++) {

System.out.print(i+"\t"); if(i%5!=0) { continue; //如果i不能被5整除则跳出这次循环，忽略下面的换行 } //当i被5整除时，if条件不满足，则不执行continue跳出循环的操作，这时可以执行一次下面的换行操作 System.out.println(" ");

}

//实例效果

1 2 3 4 5  

6 7 8 9 10  11 12 13 14 15  

16 17 18 19 20  

return：return语句用来明确地从一个方法返回。

也就是说，return语句使程序控制权返回到调用它的方法，因此return也属于跳转语句在一个方法的任何时间，return语句可以返回到调用它的方法

转载地址：https://blog.csdn.net/otmqixi/article/details/79820675 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！