java面向对象基础

java面向对象基础 面向对象的三条主线

• java类中的成员分为五个部分属性、方法、构造器、代码块、内部类
• 面向对象的三大特征(特性)：封装、继承、多态、(抽象)
• 面向对象时所涉及到的关键字：this、super、static、final、abstract、interface、package、import

---

面向过程和面向对象的区别和理解

• 面向过程：考虑怎么做，以动作为单位，在程序中就是以函数作为基本单位，强调的是功能行为
• 面向对象：考虑谁来做，以个体为单位，在程序中就是以类/对象为基本单位，强调的是具备功能的对象
  
  这篇博客对于面向对象和过程讲解的很全面

---

类和对象的区别

• 类：类是对，一类事物统一特征的抽象化，比如人这个概念
• 对象(实例)：就是实际存在的每个个体，比如张三、李四…

面向对象程序设计重点在于类的设计，设计类就是设计类中的成员

面向对象如何实现

• 创建类，设计类中的成员(包括属性和方法的设计)
• 创建类的对象(实例化)
• 通过对象.属性、对象.方法调用对象的结构

关于属性和方法的说明

• 属性 = 成员变量 = field = 域、字段
• 方法 = 成员方法 = 函数 = method
• 创建类的对象 = 类的实例化 = 实例化类

---

对象的创建与内存解析

• 对象的创建(类的实例化)

Person p1 = new Person();   // 创建了Person类的对象p1
Person p2 = new Person();   // 创建了Person类的对象p2
Person p3 = p1;   // 没有新创建一个对象，共用一个堆空间中的对象实体

// Person.java

package wsf.exam01;
// 类的定义
public class Person {
	// 定义的属性
	String name;
	int age;
	boolean isMale;
	
	// 定义的方法
	public void show(){
		System.out.println("我是"+name);
	}
}

// PersonTest.java

package wsf.exam01;
// 类的实例化
public class PersonTest {
	public static void main(String[] args) {
		 Person p1 = new Person();   // 创建了Person类的对象p1
		 Person p2 = new Person();   // 创建了Person类的对象p2
		 Person p3 = p1; 
		 p1.name = "小明";
		 p2.name = "小红";
		 p1.show(); //我是小明
		 p2.show(); //我是小红
		 p3.show(); //我是小明
		 System.out.println(p1 == p2); // false
		 System.out.println(p1 == p3); // true
	}
}

1. new Person()：在堆内存空间中创建了一个对象并生成了一个内存地址，对象里面就是类中定义的方法和属性成员
2. Person p1：在栈内存空间中创建了一个变量
3. =：将1中的对象地址以引用的方式存储在p1变量中

• Person p3 = p1 ：未创建新的对象，只是将p1中存放的地址给了p3，两个变量指向堆内存中同一个对象(类实例)

如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）
意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。

---

对象数组的内存解析

// PersonArrayTest.java

package wsf.exam01;
// 类数组的实例化
public class PersonArrayTest {
	public static void main(String[] args) {
		Person [] p1 = new Person[6]; // 创建一个数组长度为6，类型为Person， 数组中每个成员指向空指针null
		
		p1[1] = new Person();
		p1[2] = new Person();
		p1[3] = p1[1];
		
		p1[1].name = "Tom";
		p1[2].name = "Jony";
		
		p1[1].show();	//		我是Tom
		p1[2].show();	//		我是Jony
		System.out.println(p1[1] == p1[2]);//		false
		System.out.println(p1[1] == p1[3]);//		true
		System.out.println(p1[4]);		   //		null
		System.out.println(p1[4] == p1[5]);//		true
	}
}

---

匿名对象

• 定义：只有new的过程，没有赋值地址给一个变量的过程，称之为匿名对象(没用名字的对象)
• 特点：匿名对象因为没有地址去引用，所以只能现创建现调用，一旦结束因为没有引用就被java中垃圾回收机制所回收

new Person().name = "Tom"
new Person().name = "Jony"

• 使用场景：
  • 当方法只调用一次的时候可以使用匿名对象
  • 可以当做参数进行传递，但是无法在传参之前做其他的操作

---

JVM内存结构

• 编译完源程序以后，生成一个或多个字节码文件（xxx.class）
• 我们使用JVM中的类的加载器和解释器对生成的字节码文件进行解释运行。意味着，需要将字节码文件对应的类加载到内存中，涉及到内存解析。
• 虚拟机栈，即为平时提到的栈结构。我们将局部变量存储在栈结构中
• 堆：我们将new出来的结构（比如：数组、对象）加载在堆空间中。补充：对象的属性（非static的）加载在堆空间中。
• 方法区：类的加载信息、常量池、静态域
  关于详细的JVM内存结构引荐下面两篇博客，等后期整理出再另开一篇博客细讲
  JVM内存模型1
  JVM内存模型2

---

类的两个重要结构之一：属性

• 属性和局部变量的区别
• 相同点：

   1.1 定义变量的格式：数据类型  变量名 = 变量值
   1.2 先声明，后使用
   1.3 变量都有其对应的作用域 (三级所用域`全局(成员变量)`、`方法体内(局部变量)`、`块级作用域`)

• 不同点：

2.1 在类中声明的位置的不同
 		属性：直接定义在类的一对{}内
 		局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量

2.2 关于权限修饰符的不同
		属性：可以在声明属性时，指明其权限，使用权限修饰符。
		常用的权限修饰符：private、public、缺省、protected  --->封装性
		目前，大家声明属性时，都使用缺省就可以了。
		局部变量：不可以使用权限修饰符。
	
2.3 默认初始化值的情况：
	属性：类的属性，根据其类型，都默认初始化值。
				整型（byte、short、int、long：0）
				浮点型（float、double：0.0）
				字符型（char：0  （或'u0000'））
				布尔型（boolean：false）
	 			引用数据类型（类、数组、接口：null）
	
	局部变量：没默认初始化值。
		意味着，我们在调用局部变量之前，一定要显式赋值。
		特别地：形参在调用时，我们赋值即可。
	
2.4 在内存中加载的位置：
	属性：加载到堆空间中 （非static）
	局部变量：加载到栈空间

变量的分类(按照数据类型)：

8种基本数据类型：数值型(byte、short、int[系统默认类型]、long)、浮点型(float、double[系统默认类型])、字符型(char)、布尔型(false/true)
3中引用数据类型：类(class[String类在这里])、接口(interface)、数组([])

变量的分类(按照声明位置)：

成员变量()、局部变量()

• 成员变量与局部变量在内存中的图解
  

类的两个重要结构之二：方法

• 定义：方法就是一种功能
• 方法的声明：

权限修饰符  返回值类型  方法名(形参列表){
			方法体
	  }
	  //注意：static、final、abstract 来修饰的方法，后面再讲。
//ex:
public void Person(String name){
	...
} 

• 说明：
  • 权限修饰符：Java中总共有四种：public(公共)、protected(保护)、缺省、private(私有)
  • 返回值类型：
    • 如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用return关键字来返回指定类型的变量或常量：“return 数据”。
    • 如果方法没返回值，则方法声明时，使用void来表示。通常，没返回值的方法中，就不需要使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。
  • 方法名：属于标识符，遵循标识符的规则和规范，“见名知意”
  • 形参列表： 方法可以声明0个，1个，或多个形参。
    • 格式：数据类型1 形参1,数据类型2 形参2,…（具体形参列表有无，根据需求）
• 方法的使用：
  • 方法的使用中，可以调用当前类的属性或方法
  • 特殊的：方法A中又调用了方法A:递归方法。方法中，不可以定义方法

return 小结：
① 结束方法
② 针对于返回值类型的方法，使用"return 数据"方法返回所要的数据。

方法的重载

• 定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型(一同、两不同，在同一个类中，方法名相同、形参列表不同【类型不同、个数不同】)

严格按照定义判断：两同一不同

跟方法的权限修饰符、返回值类型、形参变量名、方法体都没关系！！！

• 重载只跟红色(变量类型)和绿色(变量个数)部分有关，跟其他参数无关
• 权限修饰符 返回值类型 方法名(形参类型 形参名1,形参类型 形参名2,方法名){
  方法体
  }

//如下的4个方法构成了重载
	public void getSum(int i,int j){
		System.out.println("1");
	}
	
	public void getSum(double d1,double d2){
		System.out.println("2");
	}
	
	public void getSum(String s ,int i){
		System.out.println("3");
	}
	
	public void getSum(int i,String s){
		System.out.println("4");
	}
   
//不构成重载的举例：
	//如下的3个方法不能与上述4个方法构成重载
	public int getSum(int i,int j){
		return 0;
	}
	
	public void getSum(int m,int n){
		// 无返回值
	}
	
	private void getSum(int i,int j){
		// 无返回值
	}

---

可变形参个数的方法描述

1. 可变形参列表是jdk 5.0新增的内容
2. 具体使用：
   • 2.1 可变个数形参的格式：数据类型 ... 变量名
   • 2.2 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，…
   • 2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
   • 2.4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存
   • 2.5 可变个数形参在方法的形参中，必须声明在末尾
   • 2.6 可变个数形参在方法的形参中,最多只能声明一个可变形参
   • 2.7 如果调用一个方法传入实参，优先调用明确个数及类型符合的方法，可想形参方法的调用放到所有方法的最后

// 可变形参的个数的方法定义
public void Person(String ... name){// jdk1.5以后
	// 方法体
}
public void Person(String [] name){// jdk1.5之前的解决方法，最典型的就是main方法
	// 方法体
}

// CanChange1.java
package wsf.exam01;

public class CanChange1 {
	public static void main(String[] args) {
		System.out.println("这是jdk1.5之前的 的写法String[] args");
	}
}

// CanChange2.java
package wsf.exam01;

public class CanChange2 {
	public static void main(String... args) {
		System.out.println("这是jdk1.5之后的新增 的写法String... args");
	}
}

---

java值传递机制

• 基本数据类型的值传递
  • 如果变量是基本数据类型，此时赋值的是变量所保存的数据值
• 引用数据类型的地址传递
  • 如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值

package wsf.exam01;

public class ByVal {
	public static void main(String[] args) {
//		基本数据类型(传递的是数据值)
		int a = 1;
		int b = a;
		a=2; // 修改a的值来看对b值的影响
		System.out.println(a); // 2
		System.out.println(b); // 1
		
//		引用数据类型(传递的是数据地址值)
		Person s1 = new Person();
		Person s2 = s1;
		s1.name = "Jony";
		System.out.println(s1.name);// Jony
		System.out.println(s2.name);// Jony
	}
}
// 定义Person类
class Person{
	String name = "Tom";
}

方法递归

• 定义：方法的返回值作为本方法的实参调用
• 最典型的就是斐波那契数列、汉诺塔、快排
  
• 快排
  

---

面向对象的特性之一：封装性

• 隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。
• 通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想
• 体现一：将类的属性xxx私化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值

// PropertyPrivate.java
package wsf.exam01;

public class PropertyPrivate {
	public static void main(String[] args) {
		Persons person = new Persons();
//		person.name; // The field Person.name is not visible
		person.setName("Tom");
		System.out.println(person.getName()); // Tom
	}
}
class Persons{
//	String name;
	private String name;// 私有化属性对外部封闭
	
//	通过get方法获取到name的值
	public String getName() {
		return name;
	}

//通过set方法修改name，这个过程可以添加限制条件，来限制用户恶意修改
	public void setName(String name) {
		this.name = name;
	}	
}

• 体现二：不对外暴露的私有的方法

public class Person {
	public void addPerson(){  // 公共方法创建实例后可在任意位置被调用
		...
	}

	private void delPerson(){ // 删除人只能在本类内被调用(私有方法)，创建实例后对外不可见，即实例无法调用
		...
	}
}

• 体现三：单例模式（将构造器私有化）后面介绍
• 体现四：如果不希望类在包外被调用，可以将类设置为缺省类

public class Xxx{// 该类可在外部包被调用
	...
}

class Xxx{// 该类不可在外部包被调用
	...
}

---

Java中四种权限修饰符

• 权限修饰符等级排序：private < 缺省（啥都不写） < protected < public
• 范围
  
  
  

---

类的结构之三：构造器

• 形式：权限修饰符 类名(形参列表){}

class Person{
// 构造器形式
	public Person(){  // 空参构造器
		System.out.println("Person().....");
	}
	
	public Person(String n){  // 构造器
		name = n;
	}
	
	public Person(String n,int a){ // 构造器
		name = n;
		age = a;
	}
}

• 作用：
  1. 创建对象
  2. 初始化对象的信息
  • 1.如果没显式的定义类的构造器的话，则系统默认提供一个空参的构造器
  • 2.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
  • 3.一个类中定义的多个构造器，彼此构成重载
  • 4.一个类中，至少会有一个构造器

---

javaBean:有公共的类、无参构造器、属性都有get&set方法的对象

关键字：this

• 1.this调用属性和对象

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

2.1  在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，
调用当前对象属性或方法。但是，通常情况下，我们都择省略"this."。
特殊情况下，如果方法的形参和类的属性同名时，
我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。

2.2 在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，
调用当前正在创建的对象属性或方法。但是，通常情况下，我们都择省略"this."。
特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，
表明此变量是属性，而非形参。
------------------------------------------------------------
package wsf.review.day2;

public class PersonThis {
	public static void main(String[] args) {
		PersonThis person = new PersonThis("Jony",12);

		person.addName("Tom");
		person.addAge(21);
	}
	String name;
	int age;
	
	public PersonThis(String name,int num){ // this在构造器中使用
		
		this.name = name; // 形参和成员变量一致必须显示调用
//		this.age = num;
		age = num; // 隐式调用this.age
		System.out.println("构造器中name：" + this.name);
		System.out.println("构造器中age：" + age);
	}
	

	public void addAge(int integer){ // this在方法中使用
		age = integer;
//		this.age = integer;
		System.out.println(age);
	}
	
	public void addName(String name){ // this在方法中使用
		this.name = name;
		System.out.println(name);
		System.out.println(this.name);
	}
}

• 2.this调用构造器
  ① 类的构造器中，可以显式的使用"this(形参列表)“方式，调用本类中其他构造器
  ② 构造器中不能通过"this(形参列表)“方式调用自己
  ③ 如果一个类中有n个构造器，则最多有 n - 1构造器中使用了"this(形参列表)”
  ④ 规定："this(形参列表)"必须声明在当前构造器的首行
  ⑤ 构造器内部，最多只能声明一个"this(形参列表)”，用来调用其他的构造器

package wsf.review.day2;

public class ConstructorThis {
  // this在构造器中的使用
	public static void main(String[] args) {
		new ConstructorThis(); //调用空参构造器
		System.out.println("----------------");
		new ConstructorThis("tom",21);
		System.out.println("----------------");
		new ConstructorThis("tom",21,4000.00);
	}
	
	String name;
	int age;
	double salary;
	
	public ConstructorThis(){
		// 空参构造器
		System.out.println("这是空参的构造器");
	}
	
	public ConstructorThis(String name,int age){
		this();
		System.out.println("这是需要提供name和age参数的构造器");
		this.name = name;
		this.age = age;
	}
	public ConstructorThis(String name,int age,double salary){
		this(name,age);
		this.salary = salary;
		System.out.println("这是需要提供name、age、salary参数的构造器");
	}
}

• 控制台打印结果：

这是空参的构造器
----------------
这是空参的构造器
这是需要提供name和age参数的构造器
----------------
这是空参的构造器
这是需要提供name和age参数的构造器
这是需要提供name、age、salary参数的构造器

---

属性赋值先 --> 后顺序

① 默认初始化
② 显式初始化
③ 构造器中初始化
*********************** 上述阶段是属性读取前基本都需要进行的赋值操作
④ 通过"对象.方法" 或 "对象.属性"的方式，赋值

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

---

包(package)和引入(import)的简单介绍

• 包(package)

1. 为了更好的实现项目中类的管理，提供包的概念
2. package声明类或接口所属的包，声明在源文件的首行
3. 包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”
4. 每"."一次，就代表一层文件目录。

java项目文件：src工程文件夹 ------- 多个package包 ------- 多个class类/interface接口

• 引入(import)

1. 在源文件中显式的使用import结构导入指定包下的类、接口
2. 声明在包的声明和类的声明之间
3. 如果需要导入多个结构，则并列写出即可
4. 使用"xxx.*"的方式，可以导入xxx包下的所有结构，但是如果使用的是xxx子包下的结构，则仍需要显式导入
5. 若源文件中，使用了不同包下的同名类，必须至少一个类要以全类名的方式显示。
6. 如果使用的类或接口是java.lang包下定义的，则可以省略import结构(直接使用)
7. 如果使用的类或接口是本包下定义的，则可以省略import结构(直接调用)
8. import static:导入指定类或接口中的静态结构:属性或方法(后面解释)

---

面向对象特征之二：继承性

• 继承的作用：
  ① 减少了代码的冗余，提高了代码的复用性
  ② 便于功能的扩展
  ③ 为之后多态性的使用，提供了前提
• 继承的图示
  
• 继承的结构：

class A extends B{}
A：当前类，称为子类
B：需要被当前类A继承的类，称为父类

• 继承后的结果：
  • 一旦子类A继承父类B后，子类A中就获取了父类B中声明的所有的属性和方法

  特别的，父类中声明为private的属性和方法，子类继承父类以后，仍然认为获取了父类中私的结构。只因为封装性的影响，使得子类不能直接调用父类的结构而已

  • 子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展,
  • 简单来说，继承以后子类拥有了父类所有的属性和方法，并且可以丰富自己的内容

java继承性的说明

1. 一个类可以被多个子类继承
2. Java中类的单继承性：一个类只能有一个父类
3. 子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类
4. 子类继承父类以后，就获取了直接父类以及所间接父类中声明的属性和方法
   

java.lang.Object类的理解

1. 如果没显式的声明一个类的父类，则此类默认继承于java.lang.Object类
2. 所有的java类（除java.lang.Object类之外）都直接或间接的继承于java.lang.Object类
3. 继承此类，意味着所的java类具有java.lang.Object类声明的功能

方法的重写

• 定义：在子类中定义的方法名及形参列表和父类相同的方法，称之为重写

// Person.java
package wsf.review.day2;

public class Person {
	 void show(){
		System.out.println("这是父类Person中的show方法");
	}
}

// Male.java
package wsf.review.day2;

public class Male extends Person{
	@Override //重写
	public void show() {
		System.out.println("这是子类Male中的方法show");
	}
}

// OverrideTest.java
package wsf.review.day2;

public class OverrideTest {
	public static void main(String[] args) {
		new Male().show(); // 这是子类Male中的方法show
	}
}

• 重写的规则

	 权限修饰符  返回值类型  方法名(形参列表) throws 异常的类型{
	 		//方法体
	 }

约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法
① 子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
② 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符

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

③ 返回值类型(分为void/基本数据类型/引用数据类型)：

父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void
父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类
父类被重写的方法的返回值类型是基本数据类型(比如：double)，则子类重写的方法的返回值类型必须是相同的基本数据类型(必须也是double)

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

---

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

重写与重载的区别

• 从定义角度：重载是定义的形参列表不同的同名方法；重写是在子类中定义的与父类同名同参的方法
• 从多态角度：重载没有体现多态，但是重写体现了多态
• 从编译角度：重载是编译器根据方法不同的参数表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。它们的调用地址在编译期就完成绑定。Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法，对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定”；而对于多态，只等到方法调用的那一刻，解释运行器才会确定所要调用的具体方法，这称为“晚绑定”或“动态绑定”

---

super的介绍及使用（都是在子类中操作父类的结构）

• super对应的就是父类的属性、方法、构造器
• 属性和方法

1. 我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."
2. 特殊情况：当子类和父类中定义同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性
3. 特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法

• 构造器

4. 我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器
5. "super(形参列表)"的使用，必须声明在子类构造器的首行！
6. 我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能二一，不能同时出现
7. 在构造器的首行，没显式的声明"this(形参列表)“或"super(形参列表)”，则默认调用的是父类中空参的构造器：super()
8. 在类的多个构造器中，至少一个类的构造器中使用了"super(形参列表)"，调用父类中的构造器

---

Java子类对象实例化过程（理解）

下面为Dog d = new Dog()过程

1. 从结果上看：继承性
   • 子类继承父类以后，就获取了父类中声明的属性或方法。
   • 创建子类的对象，在堆空间中，就会加载所父类中声明的属性。
2. 从过程上看：
   当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的父类的构造器，…直到调用了java.lang.Object类中空参的构造器为止。正因为加载过所的父类的结构，所以才可以看到内存中父类中的结构，子类对象才可以考虑进行调用

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

---

面向对象的特征之三：多态性

• 多态的定义：父类的引用指向子类的对象(或子类的对象赋值给父类的引用)
• 形式

Person person1 = new Man(); // new出来的对象属于子类(Man)，但定义时时父类(Person)
Person person2 = new Woman();

• 多态的使用前提：
  ① 有类之间的继承关系
  ② 有父类方法的重写

• 多态性的使用(虚拟方法的调用)：
  ①有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法
  ②总结：编译，看左边；运行，看右边

package wsf.review.day2;

public class overrideTest {
	public static void main(String[] args) {
		new Male().show();
		Person person = new Male();
		person.show(); // 多态
	}
}

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

关于向下转型和向上转型

• 在基本数据类型中存在向下转型就是我们讲到的隐式装换(类型自动转换ex:int —> double)，向上转型就是强制类型装换(显示转换ex:double —> int)
• 在引用数据类型中同样存在着向下/向上装换
• 向上装换：多态(子类 --> 父类)
• 向下转换：强转(父类 --> 子类)
• 向下转换的目的：有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。如何才能调用子类特的属性和方法？使用向下转型。
• 如何实现向下转化：使用强转符[类似于基本数据类型强转]()

1. 使用时的注意点：

① 使用强转时，可能出现ClassCastException的异常
② 为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型

2. instanceof的使用：

① a instanceof A:判断对象a是否是类A的实例。如果是，返回true；如果不是，返回false
② 如果 a instanceof A返回true,则 a instanceof B也返回true.其中，类B是类A的父类
③ 要求a所属的类与类A必须是子类和父类的关系，否则编译错误

多态性实现了代码的通用，在JDBC处理不同数据库和抽象类和接口中也有体现

---

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. Object类中equals()的定义：

    public boolean equals(Object obj) {
	        return (this == obj);
	  }

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

3. 像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后，比较的不是两个引用的地址是否相同，而是比较两个对象的"实体内容"是否相同。

4. 通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的"实体内容"是否相同。那么，我们就需要对Object类中的equals()进行重写

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

• 如何重写：

class User{
String name;
int age;
	//重写其equals()方法
	public boolean equals(Object obj){
		if(obj == this){
			return true;
		}
		if(obj instanceof User){
			User u = (User)obj;
			return this.age == u.age && this.name.equals(u.name);
		}
		return false;
	}
}

equals方法和==的区别

• ==:运算符

1. 可以使用在基本数据类型变量和引用数据类型变量中
2. 如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等（不一定类型要相同）
   如果比较的是引用数据类型变量：比较两个对象的地址值是否相同，即两个引用是否指向同一个对象实体

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

• equals方法

3. 只能用于引用数据类型中
4. 在没有重写之前，比较的是数据的地址值是否指向同一个实体对象
5. 重写后的equals目的主要用来比较数据的内容是否相同

toStrong方法的使用

1. 当我们输出一个对象的引用时，实际上就是调用当前对象的toString()
2. Object类中toString()的定义：

 public String toString() {
      return getClass().getName() + "@" + Integer.toHexString(hashCode());
   }

3. 像String、Date、File、包装类等都重写了Object类中的toString()方法。使得在调用对象的toString()时，返回"实体内容"信息
4. 自定义类也可以重写toString()方法，当调用此方法时，返回对象的"实体内容"
5. 如何重写toString()

举例：
//自动实现
	@Override
	public String toString() {
		return "Customer [name=" + name + ", age=" + age + "]";
	}

包装（封装）类的使用：

• 什么是包装类：为了使基本数据类型的变量具有类的特征，引入包装类
  
  
• 基本类、包装类、toStrong类之间的装换
  
  简易版：
  基本数据类型< — >包装类：JDK 5.0 新特性：自动装箱 与自动拆箱
  基本数据类型、包装类 —> String:调用String重载的valueOf(Xxx xxx)
  String —> 基本数据类型、包装类:调用包装类的parseXxx(String s)
  注意：转换时，可能会报NumberFormatException
  应用场景举例：
  ① Vector类中关于添加元素，只定义了形参为Object类型的方法：
  v.addElement(Object obj); //基本数据类型 —>包装类 —>使用多态

注：在包装类的Integer类中，如果定义的是-128~127之间的数，进行包装类的转换，那么，两个相同的数装换后的地址值相等

		Integer a1 = -128;
		Integer a2 = -128;
		boolean a = a1 == a2 ? true : false;
		Sysout(a); // true
		
		Integer b1 = 127;
		Integer b2 = 127;
		boolean b = b1 == b2 ? true : false;
		Sysout(b); // true
		
		Integer c1 = 128;
		Integer c2 = 128; 
		boolean c = c1 == c2 ? true : false;
		Sysout(c);  //false

static(静态)

1. 可以用来修饰的结构：主要用来修饰类的内部结构属性、方法、代码块、内部类

• 属性是否使用static修饰，又分为：静态属性 vs 非静态属性(实例变量)
  • 实例变量：我们创建了类的多个对象，每个对象都独立的拥一套类中的非静态属性。当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。
  • 静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。
• static修饰属性的其他说明：
  ① 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
  ② 静态变量的加载要早于对象的创建。
  ③ 由于类只会加载一次，静态变量在内存中也只会有一份：存在方法区的静态域中

  类变量	实例变量
  类	yes
  对象	yes

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

• 方法中static的使用
  static修饰方法：静态方法（类方法）
  ① 随着类的加载而加载，可以通过"类.静态方法"的方式进行调用

  静态方法	非静态方法
  类	yes
  对象	yes

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

static的注意点：

• 在静态的方法内，不能使用this关键字/super关键字
• 关于静态属性和静态方法的使用，大家都从生命周期的角度去理解

如何判定属性和方法应该使用static关键字：

• 关于属性
  static属性是可以被多个对象所共享的，不会随着对象的不同而不同的
  类中的常量也常常声明为static

• 关于方法
  操作静态属性的方法，通常设置为static
  工具类中的方法，习惯上声明为static的。比如：Math、Arrays、Collections

• 使用举例：
  举例一：Arrays、Math、Collections等工具类
  举例二：单例模式

单例模式

• 单例模式是23种经典的设计模式之一，所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例
• 单例模式的分类
  • ①饿汉式

package wsf.review.day2;
// 单例模式：饿汉式(The Hungry Type)

public class TheHungryType {

//	1.私有化构造器
	private TheHungryType(){}
	
//	2.在类内部创建实例对象hungry
//	4.由于3中使用了静态方法，只能调用静态变量，所以此处需要给变量添加静态修饰符
	private static TheHungryType hungry = new TheHungryType();
	
//	3.抛出实例对象给外部使用,由于没有在外部创建实例,所以想要调用类方法必须声明为静态方法
	public static TheHungryType getHungry(){
		return hungry;
	}
}

• ②懒汉式

package wsf.review.day2;
// 单例模式：懒汉式(The Lazybones Type)

public class TheLazybonesType {

//	1.私有化构造器
	private  TheLazybonesType() {}
	
//	2.创建私有化变量
//	根据3中的static方法要求，2中的属性也需要使用static
	private static TheLazybonesType lazybones = null;
	
//	3.在方法中判断是否具有对象lazybones，有就返回对象，没有就创建对象
	public static TheLazybonesType getLazybones(){
		if(lazybones == null){
			lazybones = new TheLazybonesType(); 
		}
		return lazybones;
	}
}

• 单例模式中懒汉式与饿汉式对比

• 饿汉式：
  坏处：对象加载时间过长
  好处：饿汉式是线程安全的

• 懒汉式：
  好处：延迟对象的创建
  目前的写法坏处：线程不安全 —> 到多线程内容时，再修改

---

main方法的介绍

1. main()方法作为程序的入口
2. main()方法也是一个普通的静态方法
3. main()方法可以作为我们与控制台交互的方式。（之前：使用Scanner）

// 通过mian方法与控制台进行交互
package wsf.review.day2;

public class MainInteraction {
	public static void main(String[] args) {
		for(int i = 0; i < args.length; i++){
			System.out.println(args[i]);
		}
		System.out.println(args.length);
	}
}
// eclipse中右键单击 -> Run as -> Run Configractions-> Arguments->programents中输入数据，以空格隔开->

• 如何将控制台获取的数据传给形参：String[] args?
  运行时：java 类名 “Tom” “Jerry” “123” “true”

• sysout(args[0]);//“Tom”

• sysout(args[3]);//“true” -->Boolean.parseBoolean(args[3]);

• sysout(args[4]);//报异常

小结：一叶知秋
public static void main(String[] args){//方法体}

• 权限修饰符：private 缺省 protected pubilc ---->封装性
• 修饰符：static final abstract native 可以用来修饰方法
• 返回值类型： 无返回值 / 有返回值 -->return
• 方法名：需要满足标识符命名的规则、规范；“见名知意”
• 形参列表：重载 vs 重写；参数的值传递机制；体现对象的多态性
• 方法体：来体现方法的功能

---

类的成员之四：代码块

• 代码块(初始化块)（重要性较属性、方法、构造器差一些）

1. 代码块的作用：用来初始化类、对象的信息
2. 代码块要是使用修饰符，只能使用static
3. 分类：静态代码块 vs 非静态代码块

• 静态代码块：
  内部可以输出语句
  随着类的加载而执行,而且只执行一次
  作用：初始化类的信息
  如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
  静态代码块的执行要优先于非静态代码块的执行
  静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构

static {
···
// 静态代码块内容
}

• 非静态代码块：
  内部可以输出语句
  随着对象的创建而执行
  每创建一个对象，就执行一次非静态代码块
  作用：可以在创建对象时，对对象的属性等进行初始化
  如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
  非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法

{
···
// 非静态代码块内容
}

4. 实例化子类对象时，涉及到父类、子类中静态代码块、非静态代码块、构造器的加载顺序：由父及子，静态先行

①默认初始化
②显式初始化 / ⑤在代码块中赋值
③构造器中初始化
④有了对象以后，可以通过"对象.属性"或"对象.方法"的方式，进行赋值
执行的先后顺序：① - ② / ⑤ - ③ - ④

---

final修饰符

• final：最终的,可以用来修饰类、方法、变量

• 具体的：
  final 用来修饰一个类:此类不能被其他类所继承
  比如：String类、System类、StringBuffer类

  final 用来修饰方法：表明此方法不可以被重写
  比如：Object类中getClass();

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

  • final修饰属性：可以考虑赋值的位置：显式初始化、代码块中初始化、构造器中初始化
  • final修饰局部变量：尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值以后，就只能在方法体内使用此形参，不能进行重新赋值

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

---

abstract修饰符

abstract: 抽象的

1. 可以用来修饰：类、方法

2. 具体的：
   abstract修饰类：抽象类

   • 此类不能实例化
   • 抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）
   • 开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作 —> 抽象的使用前提：继承性

   abstract修饰方法：抽象方法

• 抽象方法只有方法的声明，没方法体
• 包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法
• 若子类重写了父类中的所有的抽象方法后，此子类方可实例化
• 若子类没重写父类中的所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰

3. 注意点：
   1. abstract不能用来修饰：属性、构造器等结构
   2. abstract不能用来修饰私方法、静态方法、final的方法、final的类

---

interface修饰符

• 1.接口使用interface来定义

• 2.Java中，接口和类是并列的两个结构

• 3.如何定义接口：定义接口中的成员

• 3.1 JDK7及以前：只能定义全局常量和抽象方法

  • 全局常量：public static final的，但是书写时，可以省略不写
  • 抽象方法：public abstract的

• 3.2 JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法

• 4.接口中不能定义构造器！意味着接口不可以实例化

• 5.Java开发中，接口通过让类去实现(implements)的方式来使用
  如果实现类覆盖了接口中所有的抽象方法，则此实现类就可以实例化
  如果实现类没覆盖接口中所有的抽象方法，则此实现类必须仍为一个抽象类

• 6.Java类可以实现多个接口 —> 弥补了Java单继承性的局限性
  格式：class AA extends BB implements CC,DD,EE

• 7.接口与接口之间可以继承，而且可以多继承

---

• 8.接口的具体使用，体现多态性
• 9.接口，实际上可以看做是一种规范

Java8中关于接口的新规范（在原有基础上添加了静态方法和默认方法）

• 知识点1：接口中定义的静态方法，只能通过接口来调用
• 知识点2：通过实现类的对象，可以调用接口中的默认方法
  • 如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法
• 知识点3：如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的默认方法，那么子类在没重写此方法的情况下，默认调用的是父类中的同名同参数的方法。–> 类优先原则
• 知识点4：如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，
  • 那么在实现类没重写此方法的情况下，报错。–> 接口冲突
  • 这就需要我们必须在实现类中重写此方法
• 知识点5：如何在子类(或实现类)的方法中调用父类、接口中被重写的方法

	public void myMethod(){
		method3();//调用自己定义的重写的方法
		super.method3();//调用的是父类中声明的
		//调用接口中的默认方法
		CompareA.super.method3();
		CompareB.super.method3();
	}

package wsf.review.day3;

public class Method1 {
	public void methods(){
		System.out.println("这是class中的方法");
	}
}
// -------------------------------

package wsf.review.day3;

public interface Method2 {
	public static final int a = 1;
//	public abstract void methods();
	public default void methods(){
		System.out.println("这是Methood2中的方法methods");
	};
	
	
	public static void method(){
		System.out.println("这是Method2中的方法method");
	};
} 

// -------------------------------

package wsf.review.day3;

public interface Method3 {
	public default void methods(){
		System.out.println("这是Methood3中的方法methods");
	};
}

package wsf.review.day3;

public class InterfaceTest extends Method1 implements Method2,Method3{
	public static void main(String[] args) {
		System.out.println(a); // 1
		Method2.method();  // 这是Method2中的方法method
		
		InterfaceTest test = new InterfaceTest();
		test.myMethod();
	}
	public void myMethod(){
		super.methods();		  // 这是class中的方法
		Method2.super.methods();  // 这是Methood2中的方法methods
	}
}

---

类的成员之五：内部类

• 定义：Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类
• 内部类的分类：成员内部类（静态、非静态 ） vs 局部内部类(方法内、代码块内、构造器内)

  • 成员内部类的理解：
    一方面，作为外部类的成员：

    • 调用外部类的结构
    • 可以被static修饰
    • 可以被4种不同的权限修饰

  • 另一方面，作为一个类：

    • 类内可以定义属性、方法、构造器等
    • 可以被final修饰，表示此类不能被继承。言外之意，不使用final，就可以被继承
    • 可以被abstract修饰
• 成员内部类
• 如何创建成员内部类的对象？(静态的，非静态的)

//创建静态的Dog内部类的实例(静态的成员内部类):
Person.Dog dog = new Person.Dog();

//创建非静态的Bird内部类的实例(非静态的成员内部类):
//Person.Bird bird = new Person.Bird();//错误的
Person p = new Person();
Person.Bird bird = p.new Bird();

• 如何在成员内部类中调用外部类的结构？

class Person{
	String name = "小明";
public void eat(){
}
//非静态成员内部类
	class Bird{
		String name = "杜鹃";
		public void display(String name){
			System.out.println(name);//方法的形参   null
			System.out.println(this.name);//内部类的属性   杜鹃
			System.out.println(Person.this.name);//外部类的属性   小明
		//Person.this.eat();
		}
	}
}

• 局部内部类的使用：

//返回一个实现了Comparable接口的类的对象
	public Comparable getComparable(){
		
		//创建一个实现了Comparable接口的类:局部内部类
		//方式一：
//		class MyComparable implements Comparable{
//
//			@Override
//			public int compareTo(Object o) {
//				return 0;
//			}
//			
//		}
//		
//		return new MyComparable();
		
		//方式二：
		return new Comparable(){

			@Override
			public int compareTo(Object o) {
				return 0;
			}
		}
	}

• 注意点：
  • 在局部内部类的方法中（比如：show如果调用局部内部类所声明的方法(比如：method)中的局部变量(比如：num)的话,要求此局部变量声明为final
  • jdk 7及之前版本：要求此局部变量显式的声明为final的
  • jdk 8及之后的版本：可以省略final的声明

总结：

• 成员内部类和局部内部类，在编译以后，都会生成字节码文件。
• 格式：
  • 成员内部类：外部类$内部类名.class
  • 局部内部类：外部类$数字 内部类名.class

---

新增知识点后期补充，也可以私信找我纠错 (^--^)