Java 基础(对象) 四描述类具有的功能，比如 Math类中 sqrt()、random()...; Scanner类

对象 Object

Java 面向对象的三大方面：

Java 两大要素: 类、对象

Java 类及类的成员

属性
方法
构造器
代码块
内部类

面向对象的三大特征

封装性
继承性
多态性
(抽象性)

其它关键字

this
super
static
final
abstract
interface
package
import

面向对象

面向过程与面向对象

面向过程 Procedure Oriented Programming

面向过程，`强调的是功能行为`，以函数为最小单位，考虑怎样做

举例：人把大象装进冰箱
1. 将冰箱门打开
2. 抬起大象，放进冰箱
3. 将冰箱门关闭

面向对象 Object Oriented Programming

面向对象，将功能封装进对象，`强调具备了功能的对象`，以类/对象为最小单位，考虑谁来做

举例：人把大象装进冰箱

人 {
	打开 (冰箱) {
    	冰箱.开开();
    }
    
    抬起 (大象) {
    	大象.进入(冰箱)；
    }
    
    关闭 (冰箱) {
    	冰箱.闭合();
    }
}

冰箱 {
	打开 () {
    	// ...
    }
    
    闭合 () {
    	// ...
    }
}

大象 {
	进入 (冰箱) {
    	// ...
    }
}

面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如，抽象、分类、继承、聚合、多态等

面向对象三大特征

封装 Encapsulation
继承 Inheritance
多态 Polymorphism

面向对象的思想概述

程序员从面向过程的执行者转化为面向对象的指挥者
面向对象分析方法分析问题的思路和步骤
1. 根据问题需要，选择问题所针对的现实世界的实体
2. 从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了概念世界中的类
3. 将抽象的实体用计算机语言进行描述，形成计算机世界中类的定义；即借助计算机语言，将类构造成计算机能够识别和处理的数据结构
4. 将类实例化成计算机世界中的对象；对象是计算机世界中解决问题的最终工具

Java 语言的基本元素

类和对象

类(Class)和对象(Object)是面向对象的核心概念

类是对一类事物的描述，是抽象的、概念上的定义
对象是实际存在的该类事物的每个个体，因而也称为实例(instance)

万事万物皆对象

在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构
- Scanner、String 等
- 文件: File
- 网络资源: URL
涉及到Java语言与前端、数据库交互时，其结构在Java层面都体现为类、对象

可以理解为: 类 = 抽象概念的人; 对象 = 实实在在的某个人
面向对象程序设计的重点是类的设计
类的设计，其实就是类的成员的设计

匿名对象

理解：创建的对象没有显示的赋给一个变量名，即为匿名对象
特征：匿名对象只能调用一次，各自为战
使用：如下 class Phone

类及类的成员

Java 代码世界是由多个不同功能的类构成

属性：对应类中的成员变量

  属性 = 成员方法 = field = 域、字段

行为：对应类中的成员方法

  方法 = 成员方法 = 函数 = method

创建类及对象(面向对象思想落地实现)

创建类，设计类的成员
创建类的对象
通过 对象.属性和 对象.方法调用对象的结构

类中属性的声明和使用

属性 vs 局部变量

相同点
1. 定义变量的格式：数据类型变量名 = 变量值；
2. 先声明，后使用
3. 变量都有其对应的作用域
不同点
1. 在类中声明的位置不同：属性，直接定义在类的一对{}内；局部变量，声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
2. 权限修饰符：属性在声明时可以通过权限修饰符声明其权限，局部变量不可以使用权限修饰符
3. 常用的权限修饰符有 private、public、protected、缺省(默认) --> 封装性
4. 默认初始化值：
  - 属性: 类的属性，根据类型都有默认初始化值；整型(byte、short、int、long) = 0；浮点型(float、double) = 0.0；字符型(char) = 0(或'\u0000'); 布尔型(boolean) = false; 引用数据类型(类、String、array、接口) = null
  - 局部变量: 没有默认初始化值，在调用局部变量前一定要显示赋值
5. 两者在内存中加载的位置不同：属性(非static)-加载到堆空间中，局部变量-加载到栈空

类中方法的声明和使用

描述类具有的功能，比如 Math类中 sqrt()、random()...; Scanner类中 nextXxx()...; Arrays类中 sort()、binarrySearch()、equals()、toString()...
方法按形参分为：有形参和没有形参两种
方法按返回值分为：有返回值和没有返回值两种；void 表示没有返回值，其它值表示返回对应类性的数据
方法的声明：权限修饰符返回值类性方法名([形参列表...]) {// 方法体}
说明：
1. 权限修饰符：private(只能在类中使用)、public、protected、缺省
2. 返回值类性：有返回值 vs 无返回值；如果方法有返回值，则在声明时必须指定返回值的类型，同时方法中需要使用return关键字来返回指定类型的数据return value;；如果方法无返回值，则声明时使用void来表示，如果想要写return的话只能写return;表示结束此方法
3. 定义方法时是否需要返回值(经验)：根据题目要求、凭经验具体分析
4. 方法名：属于标识符，遵循标识符的规则和规范，‘见名知意’
5. 形参列表：方法可以声明 0个到多个形参
6. 方法体：方法功能的具体实现
7. 方法的使用，可以调用当前类的属性和方法，但在方法中不能定义方法

return 关键字的使用

使用范围: 在方法体中
作用:
1. 结束方法
2. 对有返回值类性的方法，使用 return value;
注意：return 关键字后面不能有执行语句

再谈方法

方法的重载(两同一不同)

重载的概念:

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或参数类型不同即可。
重载的特点:

与返回值类型无关，只看参数列表，且参数列表必须不同(参数个数或类型)；调用时，根据方法参数列表的不同来区分。
在通过对象调用方法时，通过方法名和参数列表来确定调用的方法

可变形参个数的方法(5.0): (0 - 无穷)

允许直接定义能和多个实参相匹配的形参；从而，可以用一种更简单的方式，来传递个数可变的实参
格式: (数据类型 ... 参数名)
可变参数个数的方法与本类中相同方法名，形参类也相同的数组之间不能共存，error
可变个数形参在方法中只能声明在末尾、且一个方法只能有一个可变个数形参

方法参数的值传递机制 !!!

方法，必须由其所在类或对象调用才有意义；若方法含有参数：
- 形参: 方法声明时的参数
- 实参: 方法调用时实际传给形参的参数值
Java 的参数值如何传入方法:

Java里方法的参数传递方式只有一种: 值传递，即将实际参数值的副本(复制品)传入方法内，而参数本身不受影响
- 形参是基本数据类型: 将实参基本数据类型变量的数据值传递给形参
- 形参是引用数据类型: 将实参引用数据类型变量的地址值传递给形参

递归方法

一个方法体内调用它自身
方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无需循环控制
递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环
应用: 快排

// 1-100之间所有自然数的和
public int sum(int num) {
	if(num == 1) {
    	return 1;
    }else {
    	return num + sum(num - 1);
    }
}

public class OOP {
	public static void main(String[] args) {
    	// create Person instance
        Person p1 = new Person();
        // Scanner scan = new Scanner(System.in);
        
        // use Person field and method
        p1.name = "jery";
        p1.isMale = true;
        System.out.println(p1.name); // jery
        p1.eat(); // eate food!
        p1.talk("Chinese"); // person can talk, use: Chinese
        // 每个对象都有自己独立的空间
        Person p2 = new Person();
        p2.name = "Tom";
        System.out.println(p2.isMale); // false
        p2.talk("English"); // person can talk, use: English
        
        Person p3 = p1; // address value
        System.out.println(p3.name); // jery
        p3.age = 10;
        System.out.println(p1.age); // 10
        
        // 匿名对象，各自为战
        new Phone().price = 1999;
        new Phone().playGame();
        new Phone().phonePrice(); // 0.0
        
        PhoneMall pMall = new PhoneMall();
        pMall.showPhone(new Phone()); // 此时可以对一个匿名对象多次使用
    }
}
class Person {
	// field
	String name;
    int age = 10;
    boolean isMale;
    // method
    public void eat() {
    	// 局部变量
        String food = "西红柿鸡蛋"; 
    	System.out.println("eat food：" + food);
    }
    public void talk(String language) {
    	// language 方法形参
    	System.out.println("person can talk, use: " + language);
    }
    public void sleep(int hour) {
    	System.out.println("休息了" + hour + "个小时。");
        eat(); // 方法中还可以调方法
    }
    public String getName() {
    	// 在方法中调用属性
    	return name;
    }
    public String getNation(String nation) {
    	String info = "我的国籍是" + nation;
        return info;
    }
}
// 匿名队象的使用
class PhoneMall {
	public void showPhone(Phone phone) {
    	// 此时可以多次使用一个匿名对象
    	phone.playGame();
        phone.phonePrice();
    }
}
class Phone {
	double price;
    public void playGame() {
    	System.out.println("playGame");
    }
    public void phonePrice() {
    	System.out.println("price: " + price);
    }
}
// 圆的面积
import java.util.Scanner;
public class CircleTest {
	public static void main(String[] args) {
    	Scanner scan = new Scanner();
        Circle cir = new Circle();
        cir.radius = scan.nextDouble();
        double area = cir.getCircleArea();
        System.out.println("circle area: " + area);
    }
}
class Circle {
	bouble radius;
    public double getCircleArea() {
    	double area = Math.PI * radius * radius;
        return area;
    }
}
// 数组对象

public class StudentTest {
	public static void main(String[] args) {
		Student[] arrStu = new Student[20];
		for(int i = 0; i < arrStu.length; ++i) {
			arrStu[i] = new Student();
			arrStu[i].number = i + 1;
			arrStu[i].state = (int)(Math.random() * (4 - 1 + 1) + 1);
			arrStu[i].score = (int)(Math.random() * (100 - 0 + 1) + 0);
			if(arrStu[i].state == 3) {
				// System.out.println("i: " + i + " number: " + arrStu[i].number + " state: " + arrStu[i].state + " score: " + arrStu[i].score);
				System.out.println(arrStu[i].stuInfo());
			}
		}
		for(int i = 0; i < arrStu.length - 1; ++i) {
			for(int j = arrStu.length - 1; j > i; --j) {
				if(arrStu[j].score > arrStu[j - 1].score) {
					Student temp = arrStu[j];
					arrStu[j] = arrStu[j - 1];
					arrStu[j - 1] = temp;
				}
			}
		}
		System.out.println("*******************************");
		for(int i = 0; i < arrStu.length; ++i) {
			// System.out.println("i: " + i + " number: " + arrStu[i].number + " state: " + arrStu[i].state + " score: " + arrStu[i].score);
			System.out.println(arrStu[i].stuInfo());
		}
	}
}

class Student {
	int number;
	int state;
	int score;

	public String stuInfo() {
		return "number: " + number + " state: " + state + " score: " + score;
	}
}
// 数组对象1

public class StudentTest1 {
	public static void main(String[] args) {
		Student1[] arrStu = new Student1[20];
		for(int i = 0; i < arrStu.length; ++i) {
			arrStu[i] = new Student1();
			arrStu[i].number = i + 1;
			arrStu[i].state = (int)(Math.random() * (4 - 1 + 1) + 1);
			arrStu[i].score = (int)(Math.random() * (100 - 0 + 1) + 0);
			
		}
		
        // 调用类的方法 要先实例化类
		StudentTest1 arrTest = new StudentTest1();

		arrTest.printArr(arrStu);
		
		System.out.println("*******************************");
		
		arrTest.searchItem(arrStu, 3);

		System.out.println("*******************************");

		arrTest.sortArr(arrStu);

		arrTest.printArr(arrStu);
        
        // 无法从静态上下文中引用非静态 方法 searchItem(Student1[],int)
        // searchItem(arrStu, 3);

	}
	public void printArr(Student1[] arrStu) {
		for(int i = 0; i < arrStu.length; ++i) {
			// System.out.println("i: " + i + " number: " + arrStu[i].number + " state: " + arrStu[i].state + " score: " + arrStu[i].score);
			System.out.println(arrStu[i].stuInfo());
		}
	}
	public void searchItem(Student1[] arrStu, int state) {
		for(int i = 0; i < arrStu.length; ++i) {
			if(arrStu[i].state == state) {
				// System.out.println("i: " + i + " number: " + arrStu[i].number + " state: " + arrStu[i].state + " score: " + arrStu[i].score);
				System.out.println(arrStu[i].stuInfo());
			}
		}
	}
	public void sortArr(Student1[] arrStu) {
		for(int i = 0; i < arrStu.length - 1; ++i) {
			for(int j = arrStu.length - 1; j > i; --j) {
				if(arrStu[j].score > arrStu[j - 1].score) {
					Student1 temp = arrStu[j];
					arrStu[j] = arrStu[j - 1];
					arrStu[j - 1] = temp;
				}
			}
		}
	}
}
// 改为 student1 避免重名
class Student1 {
	int number;
	int state;
	int score;

	public String stuInfo() {
		return "number: " + number + " state: " + state + " score: " + score;
	}
}

总结

面向对象内容的三条主线

java 类及类的成员
1. 属性
2. 方法
3. 构造器
4. 代码块
5. 内部类
面向对象的三大特征
1. 封装性
2. 继承性
3. 多态性
其它关键字

谈谈你对面向对象中类和对象的理解，二者的关系

类：抽象的、概念上的内容
对象：实实在在、具体的一个个体
对象是由类派生出来的

面向对象思想的体现一：类和对象的创建和执行操作

创建类
类的实例化
通过实例调用结构(属性、方法)

类的方法内的规定

内的方法内可以定义变量
类的方法内可以调用属性
类的方法内不可以定义方法
类的方法内可以调用方法
```
talk() {
show();
}
show() {// ...}
```

方法重载

两同一不同: 同一个类，同一个方法名，参数列表不同
根据方法名和参数列表来确定被调用的具体方法

Java 方法中参数传递机制

基本数据类型: 值传递
引用数据类型: 地址值(含变量的数据类型)

成员变量和局部变量的声明位置、默认初始值、权限修饰符、内存分配位置

成员变量:
1. 声明位置: 类的 {} 内
2. 默认初始值: 有，基本数据类型；引用数据类型-null
3. 权限修饰符: public、private、protected、默认
4. 内存位置：堆空间中
局部变量:
1. 声明位置: 方法中
2. 默认初始值: 无，必须赋初始值
3. 权限修饰符: 无
4. 内存位置: 栈空间中

return 关键字

结束方法: return;
结束方法，并反回对应类型的数据: return value;

匿名对象

创建的对象，没有显示的赋给一个变量名

特点: 匿名对象只能调用一次(class Phone)

new Phone().sendEmail();
new Phone().playGame();
// 此时类Phone两次实例化产生的对象是不同的

应用:

PhoneMall mall = new PhoneMall();
mall.show(new Phone);

class PhoneMall {
	public void show(Phone phone) {
    	// 此时的phone就是同一个对象
    	phone.sendEmail();
        phone.playGame();
    }
}

对象的内存解析

Person p1 = new Person();
// 1. 在栈中p1保存对象地址值
// 2. 在堆中保存对象，及对象的属性

JVM内存结构

《JVM规范 -周》

编译完源程序后，生成一个或多个字节码文件
我们使用JVM中的类的加载器和解释器对生成的字节码文件进行解析运行(意味着将字节码文件对应的类加载到内存中，涉及到内存解析)
虚拟机栈，即平时提到的栈结构，局部变量存储在栈结构中
堆，将new出来的结构(如：数组、对象)加载到堆空间中(补充：对象的(非static)属性加载在堆空间中)
方法区：类的加载信息、常量池、静态域

面向对象特征之一: 封装与隐藏

程序设计追求: "高内聚、低耦合"

高内聚: 类的内部数据操作细节自己完成，不允许外部干涉
低耦合: 仅对外暴露少量的方法用于使用

隐藏对象内部的复杂性，只对外公开简单的接口

便于外界调用，从而提高系统的可扩展性、可维护性
通俗说: 将该隐藏的隐藏起来，该暴露的暴露出来；这就是封装性的设计思想

public class AnimalsTest {
	public static void main(String[] args) {
    	Animal a1 = new Animal();
        // a1.legs = 4; error legs is not visible
        a1.name = "Ahuang";
        a1.age = 1;
        a1.setLegs(4);
        a1.show();
        
        // 属性设置权限修饰符后，需要通过方法来重新设置其应有的功能
        // System.out.println("legs: " + a1.legs); error，无法获取legs属性
        System.out.println("legs: " + a1.getLegs());
    }
}
class Animal {
	String name;
    int age;
    private int legs; // 只能在类中使用
    
    // 属性的设置
    public void setLegs(int num) {
    	if(num >= 0 && num % 2 == 0) {
        	legs = num;
        }else {
        	// 抛出异常
        	legs = 0;
        }
    }
    // 属性的获取
    public int getLegs() {
    	return legs;
    }
    public void show() {
    	System.out.println("name: " + name + ", age: " + age + ", legs: " + legs);
    }
}

问题引入

当我们创建一个类的对象后，我们可以通过 “对象.属性” 的方式，对对象的属性进行赋值；这里，赋值操作要受到属性的类型和权限修饰符的制约；除此之外，没有其它制约条件；但是在实际操作中，我们往往需要给属性赋值添加额外的限制条件，这个条件就不能在属性声明时体现，我们一般通过方法进行限制条件的添加，同时我们需要避免用户再使用 “对象.属性” 的方式对属性进行赋值，此时就需要使用权限修饰符将属性声明为私有的(private) --> 此时，针对这个属性就体现了封装性(隐藏)

封装性的体现

如上代码、类中私有的方法、单例模式 ...

以上我们将类的属性(legs)私有化(private)，同时，提供相应的公共方法(public)来获取和设置此属性值

权限修饰符

封装性的体现，需要权限修饰符的配合

Java 规定的4种权限(从小到大): private、缺省(default)、protected、public

private：类内部
缺省: 类内部、同一个包
protected: 类内部、同一个包、不同包的子类
public: 类内部、同一个包、不同包的子类、同一个工程

对于 class 的权限修饰只能用 public 和缺省

public类: 可以在任意地方被访问
缺省类: 只可以被同一个包内部的类访问

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

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

public class OrderTest {
	public static void main(String[] args) {
		Order order = new Order();

		order.orderDefault = 10;
		order.orderPublic = 20;
		// order.orderPrivate = 100; error, field orderPrivate is not visible

		order.methodDefault();
		order.methodPublic();
		// order.methodPrivate(); error, method methodPrivate is not visible
	}
}

public class Order {
	private int orderPrivate;
	int orderDefault;
	public int orderPublic;

	private void methodPrivate() {
		orderPrivate = 0;
		orderDefault = 1;
		orderPublic = 2;
		System.out.println("methodPrivate");
	}
	void methodDefault() {
		System.out.println("methodDefault");
	}
	public void methodPublic() {
		System.out.println("methodPublic");
	}
}

类的成员之三: 构造器constructor(构造方法)的使用

任何一个类都有构造器，一般在开发中都会给类提供一个空参的 constructor

构造器的作用:

构造器也有重载

创建对象
初始化对象的信息

public class PersonTest {
	public static void main(String[] args) {
    	// 创建类的对象: new + 构造器
    	Person p1 = new Person();
        p1.eat();
        
        Person p2 = new Person("Tom");
        System.out.println("name: " + p2.name); // Tom
    }
}

class Person {
	// field
	int age;
    String name;
    
    // 构造器
    public Person () {
    	System.out.println("Person()...");
    }
    public Person(String n) {
    	name = n; //初始化属性
    }
    public Person(String n, int a) {
    	name = n;
        age = a;
    }
    
    // method
    public void eat() {
    	System.out.println("eat");
    }
}

如果没有显示的定义类的构造器的话，则系统默认提供一个空参的构造器
定义构造器的格式: 权限修饰符类名(参数列表){}
一个类中定义的多个构造器，彼此构成重载，方法的重载规则类似
一旦我们显示的定义了类的构造器之后，系统就不再提供默认的空参构造器
一个类中至少会有一个构造器(默认、自己写)

总结: 属性赋值的先后顺序

顺序是: 1 - 2 - 3 - 4

默认初始化
显示初始化
构造器初始化
通过对象.属性或对象.方法赋值

以上，前三步只会执行一次，第四布可以反复执行

JavaBean

JavaBean 是一种Java语言写成的可重用组件

所谓 JavaBean，是指符合如下标准的 Java类

类是公共的 public
有一个无参的公共的构造器(默认提供的构造器的权限与类的权限一致)
有属性，且有对应的 get、set 方法

用户可以使用 JavaBean 将功能、处理、值、数据库访问和其它任何可以用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面，Servlet、其它JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴功能，而不用关心任何改变

// JavaBean 举例
public class Customer {
	private int id;
    private String name;
    // 用于反射
    public Customer() {
    	
    }
    
    public void setId(int i) {
    	id = i;
    }
    public int getId() {
    	return id;
    }
    public void setName(String n) {
    	name = n;
    }
    public String getName() {
    	return name;
    }
}

关键字:

this

在类的方法、构造器中，我们可以使用 this.属性 或 this.方法 的方式，调用当前(正在创建的对象)对象属性或方法；但是在通常情况下，我们都选择省略 this.

在Java中，this关键字比较难理解，它的作用和其词义很接近
this 理解为: 当前对象或当前正在创建的对象

它在方法内部使用，即这个方法所属对象的引用
它在构造器内部使用，表示该构造器正在初始化的对象

this 表示当前对象，可以调用类的 属性、方法和构造器
this 关键字的使用时机

当在方法内需要用到调用该方法的对象时，就用this
- 例如: 使用this来区分局部变量和属性 this.name = name;
this 调用构造器 (降低代码冗余)
- 在类的构造器中，可以使用 this(形参列表) 的方式，调用本类中其它的构造器
- 规定: this(形参列表) 必须声明在当前构造器的首行
- 构造器内部，只能调用一次其它构造器

public class PersonTest {
	public static void main(String[] args) {
    	Person p1 = new Person();
        p1.eat();
    }
}
class Person {
	private String name;
    private int age;
    
    public Person() {
    	this.eat();
    }
    // 2. this 在构造器中使用
    public Person(String name) {
    	this();
    	this.name = name;
    }
    public Person(int age) {
    	this();
    	this.age = age;
    }
    public Person(String name, int age) {
    	// 3. this 调用构造器,根据参数调用不同的构造器
        this(name);
    	//this.name = name;
        this.age = age;
        //this.eat();
    }
    
    // 1. this 用来修饰属性
    public void setName (String name) {
    	this.name = name;
    }
    public String getName() {
    	return this.name;
    }
    public void setName(int age) {
    	this.age = age;
    }
    public int getName() {
    	return this.age;
    }
    public void eat() {
    	System.out.println("eat");
        this.study();
    }
    public void study() {
    	System.out.println("study");
    }
}

package、import 的使用

package 关键字的使用

为了更好的实现目录中类的管理，提供包的概念
使用package声明类或接口所属的包，声明在源文件的首行
包，属于标识符，遵循标识符的命名规范(xxyyzz) 见名知意
每 . 一次，就代表一层文件目录 package com.atbj.java

补充: 同一个包下，不能命名同名的接口、类，不同包下可以命名同一个接口、类

import 关键字的使用

import: 导入

在源文件中显示的使用 import 结构导入指定包下的 类、接口
声明在包的下面，第一个类的上面，如需导入多个接口，并列写出即可
xxx.* 表示导入 xxx 包下的所有结构
定义在 java.lang 包下的结构可以直接使用
同一个包下的结构，可以省略导入
导入不同包下的同名结构时，为防止混乱，必须使用全类名方式进行显示 com.atbj.java.Bank
使用 xxx.* 方式表明可以调用 xxx 包下所有的类、接口；但如果使用的是 xxx包下的子包的结构，仍需要显示导入子包的结构
import static xxx.xxx: 导入指定类或接口中的静态结构(属性、方法、*)

package com.atbj.java;
// import java.util.Arrays;
// import java.util.HashMap;
import com.atbj.java.bank;
import java.util.*;

import static java.lang.System.*; // 表示导入 System 下的所有静态结构

public class ImportPackage {
	public static void main(String[] args) {
    	String arrInfo = Arrays.toString(new int[]{1, 2, 3});
        
        // System.out.println("out");
        out.println("out");
    }
}

总结:

构造器的作用，使用中的注意要点

创建对象、初始化对象信息
构造器没有返回值、构造器的名称和类名保持一致、一个类至少会有一个构造器

关于类的赋值，有几种方式，谈谈赋值的先后顺序

顺序: 默认初始化、显示初始化、构造器初始化、对象.方法、对象.属性

this 关键字可以用来调用的结构，并简单说明使用

属性调用: this.属性;
方法调用: this.方法();
构造器调用: this(参数列表);

Java 中目前学习的四种权限修饰，并说明其范围(可见性)

public: 整个项目
protected: 不同包下的子类
缺省: 同一个包下
private: 同一个类中

补充: class类只能使用 public、缺省的两种

为什么要引入封装性

高内聚: 类内部的数据操作自己完成，不允许外部干涉
低耦合: 仅对外暴露少量的方法使用
封装性的体现
- 属性私有化，通过方法进行设置、获取
- 不对外暴露的私有方法
- 单例模式(构造器私有化)
- 将类设置成缺省的

构造器: 只要创建对象就需要构造器

作用: 创建对象、初始化对象信息
格式: 权限修饰符类名(参数列表){}
一个类中，至少会有一个构造器

JavaBean

类是 public
一个无参的公共的构造器
属性，且有对应的 get、set 方法