尚硅谷Java学习笔记第二天（java基本语法）

1：关键字和保留字

关键字(keyword)的定义和特点

定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）

特点：关键字中所有字母都为小写

Java保留字：现有Java版本尚未使用，但以后版本可能会作为关键字使 用。自己命名标识符时要避免使用这些保留字 goto 、const

2：标识符（命名规则）

标识符：

Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符

技巧：凡是自己可以起名字的地方都叫标识符。

定义合法标识符规则：

（如果不遵守如下规则，编译不通过！严格遵守）

由26个英文字母大小写，0-9 ，_或 $ 组成

数字不可以开头。

不可以使用关键字和保留字，但能包含关键字和保留字。

Java中严格区分大小写，长度无限制。

标识符不能包含空格。

Java中的名称命名规范：

（如果不遵守如下规则，编译可以通过，建议遵守）

包名：多单词组成时所有字母都小写：xxxyyyzzz

类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz

pubilc class StudyTest{
    
}

变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个 单词首字母大写：xxxYyyZzz

public void getName{
	boolean isFlag = ture;
}

常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

注意1：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。

注意2：java采用unicode字符集，因此标识符也可以使用汉字声明，但是不建议使用。

3：变量

变量的概念：

内存中的一个存储区域

该区域的数据可以在同一类型范围内不断变化

变量是程序中最基本的存储单元。包含变量类型、变量名和存储的值

变量的作用：

用于在内存中保存数据

使用变量注意：

Java中每个变量必须先声明，后使用

使用变量名来访问这块区域的数据

其定义所在的一对{ }内，变量只有在其作用域内才有效

同一个作用域内，不能定义重名的变量

声明变量

语法：<数据类型> <变量名称>

例如：int var;

变量的赋值

语法：<变量名称> = <值>

例如：var = 10;

声明和赋值变量

语法： <数据类型> <变量名> = <初始化值>

例如：int var = 10;

pubilc class StudyTest{
    //变量的定义
    int number = 10;
    //变量的使用
    System.out.println(number)
    
    int number;
    
    number = 10;
}

变量的分类-按数据类型

变量的分类-按声明的位置的不同

在方法体外，类体内声明的变量称为成员变量。

在方法体内部声明的变量称为局部变量。

3.1基本数据类型

1：整数类型：byte、short、int、long

Java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保 证java程序的可移植性。

java的整型常量默认为 int 型，声明long型常量须后加‘l’或‘L’

pubilc class StudyTest{

    
    int number = 1001;

    System.out.println(number);

    long number = 11223344l;

    System.out.println(number);
}

java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long

2：浮点类型：float、double

与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体操作 系统的影响。

浮点型常量有两种表示形式：

十进制数形式：如：5.12 512.0f .512 (必须有小数点）

科学计数法形式:如：5.12e2 512E2 100E-2

float:单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。

double:双精度，精度是float的两倍。通常采用此类型。

Java 的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’。

3：字符类型：char

char 型数据用来表示通常意义上“字符”(2字节)

Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字 母，一个汉字，或其他书面语的一个字符。

字符型变量的三种表现形式：

字符常量是用单引号(‘ ’)括起来的单个字符。

pubilc class StudyTest{		
    char c1 = 'a';
    System.out.println(c1);
}

Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。 例如：char c3 = ‘\n’; // '\n’表示换行符

pubilc class StudyTest{		
    char c2 = '\n';
    System.out.print("hello" + c2);
    System.out.println("world");
    //hello
    //world
}

直接使用 Unicode 值来表示字符型常量：‘\uXXXX’。其中，XXXX代表 一个十六进制整数。如：\u000a 表示 \n。

char类型是可以进行运算的。因为它都对应有Unicode码。

4：布尔类型：boolean

boolean 类型用来判断逻辑条件，一般用于程序流程控制：

if条件控制语句；

while循环控制语句；

do-while循环控制语句；

for循环控制语句；

boolean类型数据只允许取值true和false，无null。

不可以使用0或非 0 的整数替代false和true，这点和C语言不同。

Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达所操作的 boolean值，在编译之后都使用java虚拟机中的int数据类型来代替：true用1表示，false 用0表示。———《java虚拟机规范 8版》

5：基本数据类型转换

自动类型转换：容量小的类型自动转换为容量大的数据类型。数据类型按容 量大小排序为：

有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的 那种数据类型，然后再进行计算。

byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型。

boolean类型不能与其它数据类型运算。

当把任何基本数据类型的值和字符串(String)进行连接运算时(+)，基本数据类 型的值将自动转化为字符串(String)类型。

6：强制类型转换

自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使 用时要加上强制转换符：()，但可能造成精度降低或溢出,格外要注意。

通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可 以实现把字符串转换成基本类型。

如： String a = “43”; int i = Integer.parseInt(a);

boolean类型不可以转换为其它的数据类型。

pubilc class StudyTest{	
    //精度损失举例1
    double d1 = 12.1;
    //截断操作
    int i1 = (int)d1;
    System.out.println(i1);//12
    ///精度损失举例2
    int i2 = 128;
    byte b = (byte)i2;
    System.out.println(i2);//-128

}

3.2：引用数据类型

1：符串类型：String

String不是基本数据类型，属于引用数据类型

使用方式与基本数据类型一致。

例如：String str = “abcd”;

一个字符串可以串接另一个字符串，也可以直接串接其他类型的数据。例如： str = str + “xyz” ; int n = 100; str = str + n;

pubilc class StudyTest{	
	String str = "abcd";
	 System.out.println(str);
	
}

5：进制

6：运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

1：算术运算符

算术运算符的注意问题

如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。 但被模数是 负数则不可忽略。此外，取模运算的结果不一定总是整数。

对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只 保留整数部分而舍弃小数部分。 例如：int x=3510;x=x/1000*1000; x的 结果是？

“+”除字符串相加功能外，还能把非字符串转换成字符串.例如： System.out.println(“5+5=”+5+5); //打印结果是？ 5+5=55 ?

/*
算术运算符
+ - * / % 前++ 后++ 前-- 后-- +连接运算符
*/
class AriTest{
	public static void main (String[] args){
		//除号：/
		int num1 = 12;
		int num2 = 5;
		int result1 = num1/num2;//2
		System.out.println(result1);
		
		int result2 = num1/num2*num2;
		System.out.println(result2);//10 默认int型

		double result3 = num1/num2;
		System.out.println(result2);//2.0
		
		double result4 = num1/num2 + 0.0;//2.0
		double result5 = num1/(num2 + 0.0);//(num2 + 0.0)强转为double类型
		double result6 = (double)num1/num2;//2.4
		double result7 = (double)(num1/num2);//2.0
		System.out.println(result5);
		System.out.println(result6);
		System.out.println(result7);
	}
}

class AriTest{
	public static void main (String[] args){
		//%取余运算
        //结果的符号与被模数的符号相同
        //开发中，经常使用%来判断能否被除尽的情况
		int m1 = 12;
		int n1 = 5; 
		System.out.println("m1%n1 = " + m1%n1);//2

		int m2 = -12;
		int n2 = 5;
		System.out.println("m2%n2 = " + m2%n2);//-2

		int m3 = 12;
		int n3 = -5;
		System.out.println("m3%n3 = " + m3%n3);//2

		int m4 = -12;
		int n4 = -5;
		System.out.println("m3%n3 = " + m4%n4);//-2
		
	}
}

class AriTest{
	public static void main (String[] args){
		//前++:先自增1，然后再运算
		//后++：先运算，后自增1
		int a1 = 10;
		int b1 = ++a1;//(=)是赋值符号
		System.out.println("a1 = " + a1 + ",b1 = " + b1 );//a1:11 b1:11
		
		int a2 = 10;
		int b2 = a2++;
		System.out.println("a2 = " + a2 + ",b2 = " + b2 );//a2:11 b2:10

        int a3 = 10;
		a3++;
		int b3 = a3;
        
        //注意点
        short s1 = 10;
        s1 =  s1 + 1;//编译失败，+1是int型。会导致精度损失。
        s1 = (short)(s1 + 1);//正确的
        s1++;//自增1不会改变本身变量的数据类型
        System.out.println(s1);
        
        //问题
        byte bb1 = 127;
        bb1++;
        System.out.println(bb1);//-128  
	}
}

/*
练习2
随意给出一个整数，打印显示它的个位数，十位数，百位数的值。
格式如下：
数字xxx的情况如下：
个位数：
十位数：
百位数：
例如：
数字153的情况如下：
个位数：3
十位数：5
百位数：1
*/
class AriExer{
	public static void main (String[] args){
        
        int num = 153;
        int bai = num/100;
        int shi = num%100/10;
        int ge = num%10/
        System.out.println("百位为：" + bai);
        System.out.println("十位为：" + shi);
        System.out.println("个位为：" + ge);       
    }

2：赋值运算符

符号：=

当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制 类型转换原则进行处理。

支持连续赋值。

扩展赋值运算符： +=, -=, *=, /=, %=

/*
赋值运算符
= += -= *= /= %= 
*/
class	SetValueTest{
	public static void main (String[] args){
		//赋值符号：=
		int i1 = 10;
		int j1 = 10;

		int i2,j2;
		//连续赋值
		i2 = j2 = 10;

		int i3 = 10, j3 = 20;
        //+= -= *= /= %=
        int num1 = 10;
        num1 += 2;
        System.out.println(num1); 
        
        short s1 = 10;
        s1 = s1 + 2;//编译失败
        s1 += 2；//不会改变数据的类型 同++
        System.out.println(s1);//11 
        //开发中，如果希望变量实现+2的操作，有几种办法？（前提：int num = 10;）
        //方式一
        num = num + 2;
        //方式二(推荐):不会改变数据的类型
        num += 2;
        
        //练习
        int n = 10;
 		n += (n++) + (++n);
		System.out.println(n);//32

	}
}

3：比较运算符（关系运算符）

class	CompareTest{
	public static void main (String[] args){
		
		int i = 10;
		int j = 20;
		System.out.println(i == j);//false
        //先将j赋值给i，再输出i
		i = j;
		System.out.println(i);
        //先运算（）内，再输出
		System.out.println(i = j);//20        
	}
}

4：逻辑运算符（重点）

&—逻辑且（与） | —逻辑或 ！—逻辑非 （a是true就是false，a是false就是

（有一个false就false） （有一个true就true） true）

&& —短路且（与） || —短路或 ^ —逻辑异或 （相同就是false，不同就是true）

/*
逻辑运算符
& && | || ！ ^
说明：
1.逻辑运算符操作的都是boolean类型的变量
*/
class	LogicTest{
	public static void main (String[] args){
		//区分 & 与 &&
		//相同点1：& 与&&的运算结果相同
		//相同点2：当符号左边是true时，二者都会执行符号右边的运算
		//不同点：当符号左边是false时，&继续执行符号右边的运算&&不会执行符号右边的运算
        //推荐使用&&
		boolean b1 = true;
		b1 = false;
		int num1 = 10;
		if(b1 & (num1++ > 0)){
			System.out.println("我现在在北京");
		}else{
			System.out.println("我现在在南京");
		}
        System.out.println("num1 = " + num1);//结果为11
		boolean b2 = true;
		b2 = false;
		int num2 = 10;
		if(b2 && (num2++ > 0)){//&&
			System.out.println("我现在在北京");
		}else{
			System.out.println("我现在在南京");
        }
        System.out.println("num2 = " + num2);//结果为10 b2左边不执行          
	}
}

class	LogicTest{
	public static void main (String[] args){
		//区分 | 与 ||
		//相同点1：| 与 || 的运算结果相同
		//相同点2：当符号左边是false时，二者都会执行符号右边的运算
		//不同点：当符号左边是true时，|继续执行符号右边的运算 || 不会执行符号右边的运算
        //推荐使用||
		boolean b3 = false;
		b3 = true;
		int num3 = 10;
		if(b3 | (num3++ > 0)){
			System.out.println("我现在在北京");
		}else{
			System.out.println("我现在在南京");
		}

		System.out.println("num3 = " + num3);
		boolean b4 = false;
		b4 = true;
		int num4 = 10;
		if(b4 || (num4++ > 0)){//||
			System.out.println("我现在在北京");
		}else{
			System.out.println("我现在在南京");
		}
		System.out.println("num4 = " + num4);
	}
}

/*
&与&&练习
*/
int x = 1;
int y=1;
if(x++==2 & ++y==2){//&前不管是true还是false都会执行后面语句
    x =7;         //X==2是false，y==2是true。整体语句是false，所以不进入语句内
}
System.out.println("x="+x+",y="+y);//4

int x = 1,y = 1;
if(x++==2 && ++y==2){//&&前是false，后面语句不执行
    x =7;
}
System.out.println("x="+x+",y="+y);//3

/*| 与 || 练习
*/
int x = 1,y = 1;
if(x++==1 | ++y==1){// | 前是true，继续执行符号右边的运算true
    x =7;//有一个true整体就是true
}
System.out.println("x="+x+",y="+y);//9

nt x = 1,y = 1;
if(x++==1 || ++y==1){//||前是true，不会执行符号右边的运算
    x =7;//有一个true整体就是true
}
System.out.println("x="+x+",y="+y);//8

5：位运算符

6：三元运算符

/*
三元运算符
1：结构：（条件表达式）？表达式1：表达式2
2：说明
 1.条件表达式的结果为boolean类型
 2.根据条件表达式真或假，决定执行表达式1，还是表达式2
   如果表达式为true，则执行表达式1
   如果表达式为false，则执行表达式2
3：表达式1和表达式2要求是一致的。
4：三元运算符可以嵌套使用
5：三元运算符都可以改写成if-else，反之不成立
6：如果既可以用三元运算符又可以用if-else，优先使用三元运算符
*/
class	SanYuanTest{
	public static void main (String[] args){

		//获取两个整数的较大值
		int m = 12;
		int n = 5;
		int max = (m > n )? m : n;
		System.out.println("max");
        
        double num = (m > n)? 2 : 1.0;\
        //(m > n)? 2 : "n大"；//编译错误
        
        String maxStr = (m > n)? "m大"："n大"；
        System.out.println(maxStr);
        
        String maxStr = (m > n)? "m大"：((m == n)? "m和n相等"："n大")；
        System.out.println(maxStr);
        
	}
}

/*
获取三个数的最大值
*/
int n1 = 12;
int n2 = 30;
int n3 = -43;
//方式一
int max = ( n1 > n2)? n1 : ((n2 > n3)? n2 : n3);
System.out.println(max);
//方式二
int max1 = ( n1 > n2)? n1 ：n2;
int max2 = ( max1 > n3)? max1 ：n3;
System.out.println(max2);

运算符的优先级