Java学习笔记01

---

Java学习详解01

---

1.Math.random()的运算

​ Math.random()是令系统随机选取大于等于 0.0 且小于 1.0 的伪随机 double 值，是Java语言常用代码。例如：double a=Math.random()*(3-1)+1，设置一个随机1到3的变量。

eg：

//年级[1,6]
stus[i].state=(int)(Math.random()*(6-1+1)+1);//(6-1+1)表示0到6的范围，因为要求的是<=6.所以括号里面有一个+1；括号外面的=1是因为所需范围是>=1,而Math.random()的默认取值是从零开始，所以需要+1

2.面s向对象的编程思想

类，对象；面向对象的三大特征；……（后续补充完）

形参：方法定义时，声明的小括号内的参数

实参：方法调用时，实际传递形参的值

2.0.1内存结构

​ 栈（局部变量），堆（new出来的结构：对象（非static成员变量），数组）

​ 变量：成员变量 vs 局部变量（方法内，方法形参，构造器内，构造器形参，代码块内）

2.1重载

​ 同一类中，同一方法名，不同参数列表！

eg:

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

2.2可变个数形参

​

可变个数形参的方法
1，jdk 5.0 新增内容
2，具体使用
    2.1格式：数据类型...变量名
    2.2当调用可变个数形参时，传入的个数可以是任意个
    2.3可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
    2.4可变个数形参的方法与本类中方法名相同，形参类型也相同的数组（就是方法的参数列表是数组）之间不构成重载，换句话说，二者不能共存
    2.5可变个数形参在方法的形参中，必须声明在末尾
    2.6可变个数形参在方法的形参，最多只能声明一个可变形参

public class java07 {
    public static void main(String[] args) {
        java07 text =new java07();
        text.show(22);
        text.show("ds");
    }
    public void show(int i){
        System.out.println("nihao ");
    }
    public void show(String s){
        System.out.println("dsds");
    }
    public void show(String...strs){//可变个数形参
		for(int i=0;i<strs.length;i++){//可变形参的调用和数组的调用差不多
            sout(strs[i]);
        }
    }
}

2.3值传递

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

2.4封装性

​ 封装与隐藏：隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提 高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露 的暴露出来。这就是封装性的设计思想

“高内聚，低耦合”

高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉；

低耦合 ：仅对外暴露少量的方法用于使用。

2.4.1问题的引入

​ 当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到

属性的数据类型和存储范围的制约。除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值

加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。（比如：setLegs()）

同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有的(private).

–>此时，针对于属性就体现了封装性。

2.4.2封装性的体现

我们将类的属性xxx私有化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值

拓展：封装性的体现：① 如上 ② 不对外暴露的私有的方法 ③ 单例模式 …

2.4.3封装性的体现，需要权限修饰符来配合（划重点！！！）

1.Java规定的4种权限（从小到大排列）：private、缺省(default,什么都不用写)、protected 、public

2.4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类

3.具体的，4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类

修饰类的话，只能使用：缺省、public

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

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

2.4.4总结的封装性

​ Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小。

2.4.5构造器

	构造器（或构造方法、constructor）的使用

construct：建设、建造。 construction:CCB constructor:建设者

2.4.5.1构造器的作用

1.创建对象

2.初始化对象的信息

2.4.5.2说明：

1.如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器

2.定义构造器的格式：权限修饰符 类名(形参列表){}

3.一个类中定义的多个构造器，彼此构成重载

4.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器

5.一个类中，至少会有一个构造器。

2.5总结： 属性赋值的先后顺序

① 默认初始化

② 显式初始化

③ 构造器中初始化

④ 通过"对象.方法" 或 "对象.属性"的方式，赋值

以上操作的先后顺序：① - ② - ③ - ④

2.6 UML图

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

2.7 this关键字

2.7.1

​ this可以用来修饰、调用：属性、方法、构造器

2.7.2.this修饰属性和方法：

	 this理解为：当前对象 或 当前正在创建的对象

2.7.2.1

	在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。但是，

通常情况下，我们都选择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式

的使用"this.变量"的方式，表明此变量是属性，而非形参。

2.7.2.2

​ 在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用当前正在创建的对象属性或方法。

但是，通常情况下，我们都选择省略"this."。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式

的使用"this.变量"的方式，表明此变量是属性，而非形参。

2.7.3this调用构造器

① 我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器

② 构造器中不能通过"this(形参列表)"方式调用自己

③ 如果一个类中有n个构造器，则最多有 n - 1构造器中使用了"this(形参列表)"

④ 规定："this(形参列表)"必须声明在当前构造器的首行

⑤ 构造器内部，最多只能声明一个"this(形参列表)"，用来调用其他的构造器

​ Eg：

class Person{
   
   private String name;
   private int age;
   
   public Person(){
   	
   	String info = "Person初始化时，需要考虑如下的1,2,3,4...(共40行代码)";
   	System.out.println(info);
   }
   
   public Person(String name){
   	this();
   	this.name = name;
   	
   }
   
   public Person(int age){
   	this();
   	this.age = age;
   	
   }
   
   public Person(String name,int age){
   	this(age);
   	this.name = name;
   }
   
   public void setName(String name){
   	this.name = name;
   }
   public String getName(){
   	return this.name;
   }
   public void setAge(int age){
   	this.age = age;
   }
   public int getAge(){
   	return this.age;
   }
   
   public void eat(){
   	System.out.println("人吃饭");
   	this.study();
   }
   public void study(){
   	System.out.println("人学习");
   }
   
}

2.8 MVC的设计模式

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

2.9 package关键字的使用

1.为了更好的实现项目中类的管理，提供包的概念

2.使用package声明类或接口所属的包，声明在源文件的首行

3.包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”

4.每"."一次，就代表一层文件目录。

补充：同一个包下，不能命名同名的接口、类。

	 不同的包下，可以命名同名的接口、类。

2.10 import关键字的使用

import:导入

1. 在源文件中显式的使用import结构导入指定包下的类、接口

2. 声明在包的声明和类的声明之间

3. 如果需要导入多个结构，则并列写出即可

4. 可以使用"xxx.*"的方式，表示可以导入xxx包下的所有结构

5. 如果使用的类或接口是java.lang包下定义的，则可以省略import结构

6. 如果使用的类或接口是本包下定义的，则可以省略import结构

7. 如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示。

8. 使用"xxx.*"方式表明可以调用xxx包下的所有结构。但是如果使用的是xxx子包下的结构，则仍需要显式导入

9. import static:导入指定类或接口中的静态结构:属性或方法。

2.11 JavaBean

所谓JavaBean，是指符合如下标准的Java类：
>类是公共的
>一个无参的公共的构造器
>属性，且对应的get、set方法

Java中主要的包介绍

1.java.lang**----**包含一些Java语言的核心类，如String、Math、Integer、Thread，提供常用功能

2.java.net**----**包含执行与网络相关的操作的类和接口。

3.java.io **----**包含能提供多种输入/输出功能的类。

4.java.util**----**包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日 期日历相关的函数。

5.java.text**----**包含了一些java格式化相关的类

6.java.sql**----**包含了java进行JDBC数据库编程的相关类/接口

7.java.awt**----**包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。 B/S C/S

2.5继承性

2.5.1继承性的好处

① 减少了代码的冗余，提高了代码的复用性

② 便于功能的扩展

③ 为之后多态性的使用，提供了前提

2.5.2 继承性的格式

class A extends B{}

A:子类、派生类、subclass

B:父类、超类、基类、superclass

2.1体现：一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的属性和方法。

特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。

只有因为封装性的影响，使得子类不能直接调用父类的结构而已。

2.2 子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展。

子类和父类的关系，不同于子集和集合的关系。

extends：延展、扩展

2.5.3 Java中关于继承性的规定

​ 1.一个类可以被多个子类继承。

2.Java中类的单继承性：一个类只能有一个父类

3.子父类是相对的概念。

4.子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类

5.子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法

2.5.4

1. 如果我们没有显式的声明一个类的父类的话，则此类继承于java.lang.Object类

2. 所有的java类（除java.lang.Object类之外）都直接或间接的继承于java.lang.Object类

3. 意味着，所有的java类具有java.lang.Object类声明的功能。

2.6方法的重写(override / overwrite)

2.6.1.重写的定义

​ 子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作

2.6.2.应用

​ 重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。

2.6.3 重写的规定

​ 方法的声明： 权限修饰符 返回值类型 方法名(形参列表) throws 异常的类型{

​ //方法体

​ }

​ 约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法

① 子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同

② 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符

​ 特殊情况：子类不能重写父类中声明为private权限的方法

③ 返回值类型：

​ 父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void

​ 父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类

​ 父类被重写的方`法的返回值类型是基本数据类型(比如：double)，则子类重写的方法的返回值类型必须是相同的基本数据类型(必须也是double)

④ 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型（具体放到异常处理时候讲）

​ 子类和父类中的同名同参数的方法要么都声明为非static的（考虑重写），要么都声明为static的（不是重写）。

面试题：区分方法的重载与重写

解释：
    ① 二者的概念：
    ② 重载和重写的具体规则
    ③ 重载：不表现为多态性。
  	重写：表现为多态性。
		重载，是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不同的参数表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。它们的调用地址在编译期就绑定了。Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法。
	所以：对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定”；
	而对于多态，只等到方法调用的那一刻，解释运行器才会确定所要调用的具体方法，这称为“晚绑定”或“动态绑定”。 
	引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚绑定，它就不是多态。”

2.7 super关键字的使用

2.7.1

​ super理解父类的

2.7.2.

​ super可以用来调用：属性、方法、构造器

2.7.3 super的使用

​ 调用属性和方法

	3.1 我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用

父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."

​ 3.2 特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的

使用"super.属性"的方式，表明调用的是父类中声明的属性。

​ 3.3 特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的

使用"super.方法"的方式，表明调用的是父类中被重写的方法。

2.7.4 super调用构造器

	4.1 我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器

​ 4.2 "super(形参列表)"的使用，必须声明在子类构造器的首行！

	4.3 我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能二选一，不能同时出现

	4.4 在构造器的首行，没有显式的声明"this(形参列表)"或"super(形参列表)"，则默认调用的是父类中空参的构造器：super()

​ 4.5 在类的多个构造器中，至少有一个类的构造器中使用了"super(形参列表)"，调用父类中的构造器

2.8 子类实例化的全过程

2.8.1 从结果上来看：（继承性）

​ 子类继承父类以后，就获取了父类中声明的属性或方法。

创建子类的对象，在堆空间中，就会加载所有父类中声明的属性。

2.8.2从过程上来看

​ 当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的父类的构造器，…

直到调用了java.lang.Object类中空参的构造器为止。正因为加载过所有的父类的结构，所以才可以看到内存中有

父类中的结构，子类对象才可以考虑进行调用。

	明确：虽然创建子类对象时，调用了父类的构造器，但是自始至终就创建过一个对象，即为new的子类对象。

2.9 多态性

2.9.1.理解多态性

​ 可以理解为一个事物的多种形态。

2.9. 2.何为多态性

	对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）

2.9.3.多态的使用:虚拟方法调用

	有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。

总结：编译，看左边；运行，看右边。

2.9.4.多态性的使用前提

​ ① 类的继承关系

​ ② 方法的重写

2.9.5

​ 对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）

2.9.6 对象的多态性

​ 父类的引用指向子类的对象

2.9.7 多态的使用(虚拟方法调用)

​ 当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法--------虚拟方法调用

2.10 向下转型的使用

public class PersonTest {
	public static void main(String[] args) {
		
		Person p1 = new Person();
		p1.eat();
		
		Man man = new Man();
		man.eat();
		man.age = 25;
		man.earnMoney();
		
		//*************************************************
		System.out.println("*******************");
		//对象的多态性：父类的引用指向子类的对象
		Person p2 = new Man();
//		Person p3 = new Woman();
		//多态的使用：当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法 ---虚拟方法调用
		p2.eat();
		p2.walk();
		
		
//		p2.earnMoney();
		
		System.out.println(p2.id);//1001
		
		System.out.println("****************************");
		//不能调用子类所特有的方法、属性：编译时，p2是Person类型。
		p2.name = "Tom";
//		p2.earnMoney();
//		p2.isSmoking = true;
		//有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致
		//编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。
		
		//如何才能调用子类特有的属性和方法？
		//向下转型：使用强制类型转换符。
		Man m1 = (Man)p2;
		m1.earnMoney();
		m1.isSmoking = true;
		
		//使用强转时，可能出现ClassCastException的异常。
//		Woman w1 = (Woman)p2;
//		w1.goShopping();
		
		 
	
	}
}

instanceof关键字

​ a instanceof A :判断对象a是否是类A的实例。如果是，返回true；如果不是，返回false。
​ 使用情境：为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先
​ 进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。

​ 如果 a instanceof A返回true,则 a instanceof B也返回true. 其中，类B是类A的父类
​

java.lang.Object类

​ 1.Object类是所有Java类的根父类

​ 2.如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类

​ 3.Object类中的功能(属性、方法)就具有通用性。

属性：无

方法：equals() / toString() / getClass() /hashCode() / clone() / finalize()

	 wait() 、 notify()、notifyAll()

​ 4.Object类只声明了一个空参的构造器

面试题： == 和 equals() 区别

一、回顾 == 的使用：

== ：运算符

1. 可以使用在基本数据类型变量和引用数据类型变量中

2. 如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。（不一定类型要相同）

如果比较的是引用数据类型变量：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体

补充： == 符号使用时，必须保证符号左右两边的变量类型一致。

二、equals()方法的使用：

1. 是一个方法，而非运算符

2. 只能适用于引用数据类型

3. Object类中equals()的定义：

public boolean equals(Object obj) {

​ return (this == obj);

}

说明：Object类中定义的equals()和==的作用是相同的：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体

4. 像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后，比较的不是

两个引用的地址是否相同，而是比较两个对象的"实体内容"是否相同。

5. 通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的"实体内容"是否相同。那么，我们

就需要对Object类中的equals()进行重写.

重写的原则：比较两个对象的实体内容是否相同.

手动实现equals()的重写

@Override
	public boolean equals(Object obj) {
		
		System.out.println("Customer equals()....");
		if (this == obj) {
          return true;
       }
		
		if(obj instanceof Customer){
			Customer cust = (Customer)obj;
			//比较两个对象的每个属性是否都相同
			if(this.age == cust.age && this.name.equals(cust.name)){
				return true;
			}else{
				return false;
			}
		
			//或
			return this.age == cust.age && this.name.equals(cust.name);
		}else{
			return false;
			
		}
	
	}

手动实现

@Override
public String toString() {
   return "Customer[name = " + name + ",age = " + age + "]"; 
}

Object类中toString()的使用

1. 当我们输出一个对象的引用时，实际上就是调用当前对象的toString()

2. Object类中toString()的定义：
   public String toString() {
   return getClass().getName() + “@” + Integer.toHexString(hashCode());
   }

3. 像String、Date、File、包装类等都重写了Object类中的toString()方法。
   使得在调用对象的toString()时，返回"实体内容"信息

4. 自定义类也可以重写toString()方法，当调用此方法时，返回对象的"实体内容"

Java中的JUnit单元测试

步骤：

1. 创建Java类，进行单元测试。

   ​ 此时的Java类要求：① 此类是public的 ②此类提供公共的无参的构造器

2. 此类中声明单元测试方法。

​ 此时的单元测试方法：方法的权限是public,没有返回值，没有形参

3. 此单元测试方法上需要声明注解：@Test,并在单元测试类中导入：import org.junit.Test;

4. 声明好单元测试方法以后，就可以在方法体内测试相关的代码。

5. 写完代码以后，左键双击单元测试方法名，右键：run as - JUnit Test

说明：

​ 1.如果执行结果没有任何异常：绿条

​ 2.如果执行结果出现异常：红条

包装类(Wrapper)的使用

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

包装类样例

//包装类--->基本数据类型:调用包装类Xxx的xxxValue()
@Test
    public void text2(){
        Integer in2=new Integer(12);//转成包装类
        int i2=in2.intValue();//转换成普通数据类型
        System.out.println(i2+1);
    }

自动拆箱，自动装箱

@Test
	public void test3(){	
		//自动装箱：基本数据类型 --->包装类
		int num2 = 10;
		Integer in1 = num2;//自动装箱
		
		boolean b1 = true;
		Boolean b2 = b1;//自动装箱
		
		//自动拆箱：包装类--->基本数据类型
		System.out.println(in1.toString());
		
		int num3 = in1;//自动拆箱
		
	}
        
        //Integer内部定义了IntegerCache结构，IntegerCache中定义了Integer[],
	    //保存了从-128~127范围的整数。如果我们使用自动装箱的方式，给Integer赋值的范围在
		//-128~127范围内时，可以直接使用数组中的元素，不用再去new了。目的：提高效率

String的valueOf()

//基本数据类型、包装类--->String类型：调用String重载的valueOf(Xxx xxx)
	@Test
	public void test4(){
		
		int num1 = 10;
		//方式1：连接运算
		String str1 = num1 + "";
		//方式2：调用String的valueOf(Xxx xxx)
		float f1 = 12.3f;
		String str2 = String.valueOf(f1);//"12.3"
		
		Double d1 = new Double(12.4);
		String str3 = String.valueOf(d1);
		System.out.println(str2);
		System.out.println(str3);//"12.4"
		
	}

parseXxx(String s)

//String类型 --->基本数据类型、包装类：调用包装类的parseXxx(String s)
	@Test
	public void test5(){
		String str1 = "123";
        
		//错误的情况：
//		int num1 = (int)str1;
//		Integer in1 = (Integer)str1;
        
		//可能会报NumberFormatException
		int num2 = Integer.parseInt(str1);
		System.out.println(num2 + 1);
		
		String str2 = "true1";
		boolean b1 = Boolean.parseBoolean(str2);
		System.out.println(b1);
	}

static关键字的使用

1.static:静态的

2.static可以用来修饰：属性、方法、代码块、内部类

3.使用static修饰属性：静态变量（或类变量）

​ 3.1 属性，按是否使用static修饰，又分为：静态属性 vs 非静态属性(实例变量)

​ 实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的

​ 非静态属性时，不会导致其他对象中同样的属性值的修改。

​ 静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致

​ 其他对象调用此静态变量时，是修改过了的。

​ 3.2 static修饰属性的其他说明：

​ ① 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用

	 ② 静态变量的加载要早于对象的创建。

	  ③ 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中

​ ④ 类变量 实例变量

​ 类 yes no

​ 对象 yes yes

3.3 静态属性举例：System.out; Math.PI;

4.使用static修饰方法：静态方法

​ ① 随着类的加载而加载，可以通过"类.静态方法"的方式进行调用

​ ② 静态方法 非静态方法

​ 类 yes no

​ 对象 yes yes

​ ③ 静态方法中，只能调用静态的方法或属性

​ 非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性

5. static注意点：

5.1 在静态的方法内，不能使用this关键字、super关键字

5.2 关于静态属性和静态方法的使用，大家都从生命周期的角度去理解。

6. 开发中，如何确定一个属性是否要声明为static的？

​ > 属性是可以被多个对象所共享的，不会随着对象的不同而不同的。

​ > 类中的常量也常常声明为static

开发中，如何确定一个方法是否要声明为static的？

​ > 操作静态属性的方法，通常设置为static的

​ > 工具类中的方法，习惯上声明为static的。 比如：Math、Arrays、Collections

单例设计模式

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

1. 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。

2. 如何实现？

​ 饿汉式 vs 懒汉式

3. 区分饿汉式 和 懒汉式

饿汉式：

坏处：对象加载时间过长。

好处：饿汉式是线程安全的

懒汉式：好处：延迟对象的创建。

​ 目前的写法坏处：线程不安全。—>到多线程内容时，再修改

//饿汉式
    public class SingletonTest1 {
	public static void main(String[] args) {
//		Bank bank1 = new Bank();
//		Bank bank2 = new Bank();
		
		Bank bank1 = Bank.getInstance();
		Bank bank2 = Bank.getInstance();
		
		System.out.println(bank1 == bank2);
	}
}

//饿汉式
class Bank{
	
	//1.私有化类的构造器
	private Bank(){
		
	}
	
	//2.内部创建类的对象
	//4.要求此对象也必须声明为静态的
	private static Bank instance = new Bank();
	
	//3.提供公共的静态的方法，返回类的对象
	public static Bank getInstance(){
		return instance;
	}
}

//懒汉式
public class SingletonTest2 {
	public static void main(String[] args) {
		
		Order order1 = Order.getInstance();
		Order order2 = Order.getInstance();
		
		System.out.println(order1 == order2);
		
	}
}


class Order{
	
	//1.私有化类的构造器
	private Order(){
		
	}
	
	//2.声明当前类对象，没有初始化
	//4.此对象也必须声明为static的
	private static Order instance = null;
	
	//3.声明public、static的返回当前类对象的方法
	public static Order getInstance(){
		
		if(instance == null){
			
			instance = new Order();
			
		}
		return instance;
	}
	
}

main函数

main()方法的使用说明：

1. main()方法作为程序的入口

2. main()方法也是一个普通的静态方法

3. main()方法可以作为我们与控制台交互的方式。（之前：使用Scanner）

代码块

代码块的运行规律：由父及子，静态先行

使用样例

//非static的代码块
	{
		System.out.println("hello, block - 2");
	}
	{
		System.out.println("hello, block - 1");
		//调用非静态结构
		age = 1;
		eat();
		//调用静态结构
		desc = "我是一个爱学习的人1";
		info();
	}
//static的代码块
	static{
		System.out.println("hello,static block-2");
	}
	static{
		System.out.println("hello,static block-1");
		//调用静态结构
		desc = "我是一个爱学习的人";
		info();
		//不可以调用非静态结构
//		eat();
//		name = "Tom";
	}

1. 代码块的作用：用来初始化类、对象

2. 代码块如果有修饰的话，只能使用static.

3. 分类：静态代码块 vs 非静态代码块

4. 静态代码块

​ >内部可以有输出语句

​ >随着类的加载而执行,而且只执行一次

​ >作用：初始化类的信息

​ >如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行

​ >静态代码块的执行要优先于非静态代码块的执行

​ >静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构

5. 非静态代码块

​ >内部可以有输出语句

​ >随着对象的创建而执行

​ >每创建一个对象，就执行一次非静态代码块

​ >作用：可以在创建对象时，对对象的属性等进行初始化

​ >如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行

​ >非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法

对属性可以赋值的位置

①默认初始化

②显式初始化

③构造器中初始化

④有了对象以后，可以通过“对象.属性”或“对象.方法”的方式，进行赋值

⑤在代码块中赋值

执行 的先后顺序：① - ② / ⑤ - ③ - ④

final关键字

final:最终的

1. final可以用来修饰的结构：类、方法、变量

2. final 用来修饰一个类:此类不能被其他类所继承。

​ 比如：String类、System类、StringBuffer类

3. final 用来修饰方法：表明此方法不可以被重写

​ 比如：Object类中getClass();

4. final 用来修饰变量：此时的"变量"就称为是一个常量

​ 4.1 final修饰属性：可以考虑赋值的位置有：显式初始化、代码块中初始化、构造器中初始化

​ 4.2 final修饰局部变量：

​ 尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值

​ 以后，就只能在方法体内使用此形参，但不能进行重新赋值。

static final 用来修饰属性：全局常量