一、封装

     1.修饰符：private 代表私有的，被private修饰的内容只能在本类中使用。

     2.要求：

（1）属性私有化：属性被private修饰

（2）为私有属性提供公开的get和set方法

      a.get方法：获取私有化属性的值

public  数据类型 get属性（）{

        return this.属性名；

}

注：返回值的数据类型取决于 获取属性的数据类型

        方法名：get+属性名 （首字母大写）

      b.set方法：为私有属性赋值

public void set属性名（数据类型  变量名）{

        this.属性名=变量名；

}

注：形式参数的数据类型取决于 赋值的属性的数据类型

        方法名：set+属性名（首字母大写）

package demo;
public class TestStudent{
	public static void main(String[] args){
	Student s=new Student();
	s.setAge(300);
	System.out.println(s.getAge());
	}
}
class Student{
    private int age;
    public int getAge(){
	    return age;
    }
    public void setAge(int age){        //定义set方法相当于给属性赋值
	    this.age=age;
	}
}

二、继承

     1.继承 体现的类与类之间的一种“is-a”的关系.

举例：水杯   是一种  容器

        猫          是一种    动物

子类extends（继承）父类

语法：class 子类名 extends 父类名{}

     2.继承是一种机制，通过继承可以让子类使用父类中的属性和方法。

     3.继承不能人为，刻意的去创造。

class Animal{
	String name;
	int age;
	public void sleep(){              //
		System.out.println("Animal...sleep");
	}
	public void eat(){
		System.out.println("Animal...eat...");
	}
}
class Dog extends Animal{    
	String color;
	public void run(){
		System.out.println("狗...running...");
	}
	public void eat(){                 
		System.out.println("吃骨头");
	}
}   //不能强制继承关系（不是人为 刻意的）

继承的优点：提高代码的可复用性、可扩展性。

     4.方法的覆盖(override) 

(1) 概念：在子类中定义和父类同名的方法。(发生在父子类之间)

(2) 覆盖的要求：

a. 子类的 方法名、形参列表、返回值类型 和 父类 相同

b. 子类的访问修饰符 和 父类相同或是 比父类更宽

(3) 使用：一旦子类覆盖了父类中方法，子类覆盖后的方法优先被使用(用子类型的引用调用)。

(4) 注意：

a. 如果 子类的方法名、形参列表和父类相同，但是返回值类型不同，编译报错。

b. 如果 子类的方法名、返回值类型和父类相同，但是形式参数列表不同，编译通过，运行通过。

(5) 应用场景：当子类从父类继承的方法不足以满足自身需求时，可以将继承到方法进行覆盖。

4. 父类中属性和方法是将每一个子类的共性进行提取，决定父类中属性和方法。

(1)父类中信息是 一般的、抽象的

(2) 子类中信息是特殊的、具体的

Java继承的特点：Java中的类之间是单继承关系，一个类只能有一个直接的父类 但是可以有多个间接的父类(多级继承)

注意：Java中类之间的单继承关系，体现Java语言的简单性的特点。

6. 子类可以从父类中继承哪些内容？构造方法、属性和成员方法来思考。

(1) 构造方法不能被子类继承 

a. 构造方法的方法名必须和类名一样，子类和父类各有不同类名，所以子类继承父类的构造方法不满足 构造方法的语法要求，所以不能继承

b. 子类的属性 和方法要比父类更复杂，所以子类的构造方法需要完成更多的赋值内容，所以父类的构造 方法不满足子类构造需求，子类需要定义自身构造方法。

7. 创建对象的过程：继承 (先完成父类对象的创建，再完成子类对象的创建)

 (1) 分配空间：子类+所有的父类空间 ---》给属性赋默认值

(2) 递归的创建父类对象：

a. 初始化父类的属性：父类属性第二次赋值机会

b.执行父类的构造方法：父类属性第三次赋值的机会

(3) 完成子类对象的创建：

a. 初始化子类的属性：子类属性第二次赋值的机会

b. 执行子类的构造方法：子类属性第三次赋值的机会

8. super的应用: super()/super.  

(1) 第一种应用：

a. super() /super(实参) ：用在子类的构造方法中，指示创建子类对象时，JVM先去完成父类对象对象创 建时，调用父类哪一个构造方法

b. super(): 调用父类无参数的构造方法 super(实参)：调用父类有参数的构造方法 c.

注意：I .super()/super(实参) 必须定义在构造方法中第一行有效语句；

II. 子类的构造方法方法第一行如果没有 super()/super(实参)/ .... 的应用， 则JVM默认添加super() ; III. this()/this(实参) 和 super()/super(实参) 不能同时定义在一个构造方法中

Iv. 如果子类的构造方法的第一行语句为 this()/this(实参)，则JVM完成父类创建时不在当前的子类 的构造方法第一行语句查找 super()/super(实参) ，而是转向 this()/this(实参)指向的构造方法 的第一行查找super()/super(实参)。

(2) 第二种应用：

a. super. 用在子类的构造方法或是成员方法中 ，代表调用当前父类对象属性和成员方法

b. super.属性名 ： 调用父类的属性 super.成员方法： 调用父类的成员方法

三、多态

1. 概念：

 (1) 多态：父类型的引用 指向 子类型对象。

语法： 父类类名 引用名 = new 子类类名(实参);

引用 对象 父类型 子类型 主观类型 实际类型

(2) 用父类型的引用调用属性或是成员方法，只能调用父类中定义的属性和方法。(编译的时候检测)

(3) 运行的时候，JVM会自动的检测子类是否覆盖了父类中方法，如果子类覆盖父类中方法，则执行 子类覆盖后的方法，否则，直接执行的是父类中方法。

2. 引用之间的转换：

 (1) 父类型的引用 赋值 给 子类型的引用 ，通过强制类型转换 大类型 小类型

a. 语法： 子类类名 引用名 = (子类类名)父类型的引用名;

b. 案例：Animal a= new Dog(); Dog d = (Dog)a;

c. 结果：将父类型引用 通过强制类型转换 赋值给子类型的引用，编译一定通过,运行分为以下两种情况：

i. 如果 实际存储对象类型 和 要转换的类型一致，则编译通过，运行也通过。 Animal a= new Dog(); Dog d = (Dog)a;

ii. 如果 实际存储对象类型和要转换的类型不一致，则编译通过，运行报错，错误如下： java.lang.ClassCastException(类型转换异常)

例如： Animal a = new Cat(); // 实际存储对象类型是 ： Cat Dog d = (Dog)a; // 要转换的类型 Dog 注意：引用中实际存储的对象类型不变。

d. 如何避免类型转换异常

i. 利用 instanceof关键字避免 类型转换异常。

ii. 语法：引用名 instanceof 类名

iii. 作用：将引用中存储的实际对象类型 和 instanceof后面的类型相比较，如果实际对象类型 兼容后面的类型，结果-true,不兼容-结果为false.

Iv. 应用场景：父类型的引用利用强制类型转换为子类型时，可以利用 instanceof判断。

package demo;
public class Test5{
	public static void main(String [] args){
		Animal a=new Dog();
		Dog d=（Dog)a; 
/*
Animal a=new Dog();
		System.out.println(a instanceof Animal);
		System.out.println(a instanceof Dog);
*/
//大类型引用 赋值 给 小类型的引用 需要强制类型转换
		d.shout(); //但实际存储类型和强制转换类型不一致是，运行报错
// 子类型的引用赋值给父类性的引用，直接赋值
	Animal a=new Dog();      //没有继承关系之间不能相互复
	}
}
class Animal{
	String name;
	public void eat(){
		System.out.println("Animal..eat.父类");
	}
	public void sleep(){
		System.out.println("Animal..sleep.父类");
	}
}
class Dog extends Animal{
	public void eat(){
		System.out.println("狗吃骨头...");
	}
	public void shout(){
		System.out.println("汪汪");
	}
}

(2) 子类型 的引用 赋值 父类型的引用 ，可以直接赋值 ---》多态 小类型 大类型

a. 语法： 父类类名 引用名 = 子类型的引用名;

b. 案例：Dog d = new Dog(); Animal a = d;

(3) 不存在继承关系的双方，不允许转换，强制类型转换也不能通过，编译直接报错。

Animal a = new Dog(); Person p = (Person)a; // 编译报错

3. 多态的实际开发应用 

(1) 多态用在数组上：本类型+所有的子类型的对象都可以作为数组元素进行存储。

(2) 多态用在形式参数上：本类型+所有子类型的对象都可以作为实际参数进行传递。

(3) 多态用在返回值上：本类型+所有的子类型的对象都可以作为返回值返回。

多态体现的好处 

(1) 屏蔽不同子类之间差异性，进行统一管理

(2) 让程序更加灵活和通用