Java地基（四）----变量、对象、静态方法、判断与循环

1、变量

1.1类型划分

• 八种基本类型：byte、short、int、long、float、double、boolean、char

• 三种引用类型：类类型、接口类型、数组类型

每一种类型都可以用来声明变量，而变量的作用就是用来接收、保存、传递、操作对应的数据的。

• 变量一定是要求先声明、再赋值、再使用

  int a;//声明变量
  a = 1;//给变量赋值
  System.out.println(a);//使用变量的值
  int b = 1;//声明变量的同时就进行赋值
  System.out.println(b);//使用变量的值
  

• 不能改变变量的类型，因为之前已经声明，可以改变数据的类型（强制转换）手动和自动。

• 在不同的情况给一个变量可以赋不同的值，那么这个变量就可以表示不同的数据，也就是 说，随着程序的运行，变量所表示的值，是可以随时发生变化的

1.2按范围划分

1.2.1 局部变量

• 定义在方法中的变量，就是局部变量
• 默认值：没有默认值即必须赋值才可以使用。
• 范围：局部变量被直接包裹的大括号中，从这变量声明开始，一直到这个大括号结束

1.2.1实例变量

• 实例变量就是类中的属性，也叫做成员变量（非静态的）

• 通过类的实例（对象）来访问。

• 默认值：有默认值，参考下列默认值。

• 范围：实例变量的作用范围是当前类中所有的非静态方法中，都可以访问。

不同类型的实例变量，它们的默认值是：

• byte类型，默认值为0
• short类型，默认值为0
• int类型，默认值为0
• long类型，默认值为0L
• float类型，默认值为0.0F
• double类型，默认值为0.0D
• boolean类型，默认值false
• char类型，默认是’\u0000’
• 引用类型：null

1.3 静态方法 static与实例之间的区别

静态方法和实例方法的区别主要体现在两个方面：

• 在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式即创建对象进行访问。也就是说，调用静态方法可以无需创建对象。

• 静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制。

静态方法访问成员变量示例：

//-----------accessMember.java-----------------
class accessMember{
private static int sa; //定义一个静态成员变量
private int ia; //定义一个实例成员变量
//下面定义一个静态方法
static void statMethod(){
　　int i = 0;  //正确，可以有自己的局部变量
    sa = 10;  
　　//正确，静态方法可以使用静态变量
　　otherStat(); 
　　//正确，可以调用静态方法
　　ia = 20;  //错误，不能使用实例变量
　　insMethod(); //错误，不能调用实例方法
}
static void otherStat(){} 
//下面定义一个实例方法 
void insMethod(){
　　int i = 0;  //正确，可以有自己的局部变量
　　sa = 15;  //正确，可以使用静态变量
　　ia = 30;  //正确，可以使用实例变量
　　statMethod();  //正确，可以调用静态方法
}
} 

总结：静态方法只能访问静态成员，实例方法可以访问静态和实例成员。之所以不允许静态方法访问实例成员变量，是因为实例成员变量是属于某个对象的，而静态方法在执行时，并不一定存在对象。同样，因为实例方法可以访问实例成员变量，如果允许静态方法调用实例方法，将间接地允许它使用实例成员变量，所以它也不能调用实例方法。基于同样的道理，静态方法中也不能使用关键字this。

main()方法是一个典型的静态方法，它同样遵循一般静态方法的规则，所以它可以由系统在创建对象之前就调用。

实例对象可以访问静态成员（静态方法和静态成员变量）和实例成员（实例成员变量和实例方法）实例–毋庸置疑的：

public  class  Person{
     public  static  void  say(){
         System.out.println( "hello" );
     }
     public  static  void  main(String[] args) {
         Person.say();
         Person man=   new  Person();
         man.say();
         Person woman=   new  Person();
         woman.say();
     }
}
//运行结果
hello
hello
hello

总结：既然类都能调用，那当然实例也可以调用。就拿上面面这个例子，我定义一个人类，它有一个方法say(),代表所有人都能说话，测试的时候可以直接通过类名调用。然后我创建两个人一个男人，一个女人，理所当然他们也能说话，也就是通过实例去调用方法。

2、此对象非彼对象

java是面向对象的编程语言，在面向对象的思想中，万事万物皆为对象。

对象一般都会具有一些属性和方法:

• 属性表示对象本身的一些特点
• 方法表示对象本身的一些行为

类和对象的关系：类是对象的抽象,而对象是类的具体实例。类是抽象的,不占用内存,而对象是具体的,占用存储空

构造方法：创建对象，初始化变量

流程步骤：

分析事物–》定义类–》声明属性/方法/构造器–》编写main方法–》创建对象–》使用对象访问属 性、调用方法 --》完成功能

3、引用类型 变量注意点

基本类型变量和引用类型变量的区别：

• 基本类型变量只能接收基本类型数据，它是一种比较简单的数据，没有属性，也没有方法
• 引用类型变量只能接收引用类型数据（也就是对象），但对象是一种比较复杂的数据，它里面可以 有很多属性，也可以有很多方法

描述：

//student引用指向了id为1813，name为猴子的对象
	student = new Student(1813, "猴子");

4、操作符

4.1 比较操作符(非常好用：instanceof)：

instanceof :判断对象是否属于指定类型

stu instanceof Student

Person o = new Person();
//表示引用o所指向的对象，是不是属于Person类型
System.out.println( o instanceof Person );

4.2移位操作符：

操作符	作用
>>	算术右移位运算，也叫做【带】符号的右移运算
<<	左移位运算
>>>	逻辑右移位运算，也叫做【不带】符号的右移运算

>> 算术右移位运算

注意，这个操作的本质就是除以2^n ,这个n就是我们右移的位数。

注意，除以2^n之后，只保留整数部分 注意，正数右移之后，最左边空出的位置，都要补0 注意，负数右移之后，最左边空出的位置，都要补1

例如，正数：16 >> 3 结果是2 ，相当于 16 / 2 3 = 2

负数：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uet1kBLd-1621676506386)(C:\Users\86132\AppData\Roaming\Typora\typora-user-images\image-20210522155628411.png)]

<< 左移位运算

注意，这个操作的本质就是乘以2 n ,这个n就是我们左移的位数

注意，无论正数负数左移之后，最右边空出的位置，都要补0

注意，当左移之后，得到的数字已经超出当前类型所能表示的最大值的时候，这个值最终会被限 定到这个当前类型中，所以最终显示的值会和我们逻辑上算出的值有所不同。

例如：直接使用2进制表示数字 int a = 0b01000000000000000000000000000000; int result = a<<2; //其实这个结果已经超出了int能表示的最大值

System.out.println(result); //结果是0

特殊情况： int a = 0b00000000000000000000000000000001; System.out.println(a<<32); //结果是1 相当于1<<0 System.out.println(a<<33); //结果是2 相当于1<<1 System.out.println(a<<34); //结果是4 相当于1<<2 原因：

​ 如果移动的位数超过了该类型的最大位数，那么编译器会对移动的位数取模/取余。如果对int 型移动33位，实际上只移动了33%32=1位。如果对int型移动32位，实际上只移动了32%32=0位

>>> 逻辑右移位运算，也叫做【不带】符号的右移运算

注意，这个操作的本质就是除以2 n ,这个n就是我们右移的位数

注意，除以2 n之后，只保留整数部分

注意，正数和负数右移之后，最左边空出的位置，都要补0

例如：

12>>>1 结果是 6

-12>>>1 结果是 2147483642

注意：在操作的时候，java操作的都是计算机中的补码

正数的原码、反码、补码都是一样的

例如：数字1的原码0000 0001，反码0000 0001，补码0000 0001

负数的原码、反码、补码有所不同

例如：数字-1

原码：1000 0001

反码：1111 1110 除了符号位之外，其他按位取反 补码：1111 1111 反码基础上加1

4.3 位运算符

交互俩个变量的值，但是不是要中间变量:

//使用中间变量的情况
int a = 1;
int b = 2;
int temp = a; //a:1 b:2 temp:1
a = b;//a:2 b:2 temp:1
b = temp;//a:2 b:1
//不是使用中间变量，使用+ -操作
int a = 1;
int b = 2;
a = a+b;//a:3 b:2
b = a-b;//a:3 b:1
a = a-b;//a:2 b:1
//不是使用中间变量，使用^操作
int a = 1;
int b = 2;
a = a^b;
b = a^b;
a = a^b;

4.4逻辑运算符

&& 短路与 例如：

int a = 1;
int b = 5;
boolean result;
// a>4 这布尔表达式为false
// 后的(b++)>1就不需要计算了
// 因为当前是短路与（&&）运算，第一个false已经能够决定整个表达式的结果了
result = a>4 && (b++)>1;
System.out.println(result);//false
System.out.println(b);//输出5
// 这种情况下，a>0为true
// 必须要再进行后面表达式的计算，最终才能得到结果，所以要计算后的(b++)>1的部分
result = a>0 && (b++)>1;
System.out.println(result);//true
System.out.println(b);//输出6

• || 短路或，和上面&&的操作类似，||的逻辑是：第一个布尔表达式为true，才能决定整个表达式的结果

• & 和 && 有什么区别？

  &既可以作为二进制数字的位运算符，也可以作为布尔表达式中的逻辑运算符，但是作为逻辑运算符的 时候，&并没有&&符合的那种短路的功能。

• && 只能作为逻辑运算符，但是它会具备短路的功能。

4.5条件操作符（记得要用：z = (x > y) ? x : y;）

将x和y中，较大的数赋值给变量z:

int x = 10;
int y = 5;
int z;
z = (x > y) ? x : y;//三目运算符

5.类型转换

隐式转换也称为自动转换。

显示转换也称为强制转换/手动转换。

5.1基本类型

小转大

大转小（有风险，精度丢失）

5.2引用类型

Student s = new Student();
Object o = s;//特点：子类类型的变量，可以自动转为（隐式）父类类型
Object o = new Student();
Student s = (Student)o;//特点：父类类型的变量，需要强制转为（显式）子类类型

注意：子类可自动转为它的夫类型，而父类不一定可以强制转换为他的子类型

6.流程控制

6.1 判断

6.1.1 if（基本）

if (关系表达式1) {
	语句体1;
}
else if (关系表达式2) {
	语句体2;
}
…
else {
	//else代码;
}
	//其他代码

6.1.2 switch （选择性判断）

• switch默认只支持byte、short、int、char这四种 类型的比较，没有long，JDK8中也允许String类型的变量做对比。没有boolean
• 注意，使用switch来完成的功能，同样可以使用if来完成，但是使用if完成的功能，使用switch不一 定能完成。
• case 应该是固定的值

switch (表达式) {
case 1:
语句体1;
break;
case 2:
语句体2;
break;
...
default:
语句体n+1;
break;
}

6.2 循环

使用场景：

1、明确循环次数，推荐使用for

2、不明确循环次数，推荐使用while

3、do…while 很少使用

6.2.1 for循环

for (初始化语句;条件判断语句;条件控制语句) {
	循环体语句;
}

死循环：一些无法判断循环次数

6.2.2 while循环

初始化语句;
while (条件判断语句) {
循环体语句;
条件控制语句;
}

6.2.3 do-while

初始化语句;
do {
循环体语句;
条件控制语句;
}while(条件判断语句

6.2.4 lable

注意，默认情况下，在嵌套循环中，break和continue只能默认对当前循环起作用。

test1:for(int i=0;i<3;i++){//外层循环
	test2:for(int j=0;j<5;j++){//内层循环
		if(j==2){
			break test1;
		}
		System.out.println("i="+i+",j="+j);
	}
	System.out.println("----------------------");
}