封装：

1、概念：

　　将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。

2、意义：

　　只能通过规定的方法访问数据。

隐藏类的实例细节，方便修改和实现。　

3、实现步骤：

public class Encapsulation {
public static void main(String[] args) {
Person person = new Person("张三", 200, 30000);
System.out.println(person.message());
}
}

class Person{
public String name;
private int age;
private double salary;

public Person() {
}

// 构造方法可以破解封装，那么如果既要实用构造器又要封装呢？
// 将set写在构造器里面
public Person(String name, int age, double salary) {
// this.name = name;
// this.age = age;
// this.salary = salary;
setName(name); setAge(age); setSalary(salary);
}

public String getName() {
return name;
}

public void setName(String name) {
if (name.length() >=2 && name.length() <=6) {
this.name = name;
} else {
this.name = "张三";
}
}

public int getAge() {
return age;
}

public void setAge(int age) {
if (age >= 1 && age <= 150) {
this.age = age;
} else {
System.out.println("输入的年龄不对，需要在1~150之间");
this.age = 16; // 给一个默认的年龄
}
}

public double getSalary() {
return salary;
}

public void setSalary(double salary) {
this.salary = salary;
}

public String message() {
return "姓名为：" + name + " " + "年龄为：" + age + " " + "工资为：" + salary;
}
}

继承：

1、定义：继承是类与类的一种关系，是一种“is a”的关系。比如“狗”继承“动物”，这里动物类是狗类的父类或者基类，狗类是动物类的子类或者派生类。

2、继承意义：

　　子类拥有父类的所有属性和方法（除了private修饰的属性不能拥有）从而实现了实现代码的复用。

3、语法规则：只要在子类加上extends关键字继承相应的父类就可以了。

4、注意点：

　　a、子类继承了父类所有的属性和方法，非私有的属性和方法可以在子类直接访问，

但是私有的属性和方法不能再子类直接访问，要通过父类提供的公共方法区访问。

public class Student {
public int score1 = 100;
public int score2 = 80;
private int score3 = 90;

// 父亲提供一个public方法，返回score3
public int getScore3() {
return score3;
}

public void test1() {
System.out.println("学生正在考试数学");
}

public void test2() {
System.out.println("学生正在考试英语");
}

private void test3() {
System.out.println("学生正在考试语文");
}

// 父亲提供一个public方法，调用test03
public void callTest() {
test3();
}

}

　　b、子类必须调用父类的构造器，完成父类的初始化。

　　c、当创建子类对象时，不管使用子类哪个构造器，默认情况都会去调用父类的无参构造器。

　　     如果父类没有提供无参构造器，则必须在子类的构造器中用supre去指定使用父类的哪个构造器完成对父类的初始化工作，否则编译 不会通过。

　　d、如果希望指定去调用父类的某个构造器，则需要显示的调用一下：super（参数列表）；

　　e、super在使用时，必须放在构造器第一行（super只能在构造器中使用）。

　　f、super()和this()都只能放在构造器第一行，因此两个方法不能共存在一个构造器中。

　　g、Java中所有类都是object类的子类。

　　h、父类构造器的调用不限于直接父类，将一直往上追溯到object类（顶级父类）。

　　i、子类最多只能继承一个父类，即Java中的单继承机制。如果要让A继承B类和C类呢？【A继承B，B继承C】。

　　j、不能滥用继承，子类和父类必须满足is-a的逻辑关系：如 猫是动物。

继承内存图：

继承中this和super：

public class ExtendsHomeWork {
public static void main(String[] args) {
C c = new C();
}
}

super关键字：

1、定义：super代表父类的引用，用于访问父类的属性、方法、构造器。

2、基本用法：

　　a、用于访问父类的属性，但不能访问父类的private属性：super.属性名;

　　b、用于访问父类的方法，但不能访问父类private方法：super.方法名(参数列表);

　　c、访问父类的构造器：super(参数列表); 只可以放在构造器第一句，只能出现一句。

3、意义及细节：

　　a、super调用父类构造器的意义（分工明确，父类的属性由父类初始化，子类的属性由子类初始化）。

class NotePad extends Computer {
private String color;

public NotePad(String cpu, int memory, int disk, String color) {
super(cpu, memory, disk);
this.color = color;
}
}

　　b、当子类和父类中的成员（属性和方法）重名时，为了访问父类成员，必须通过super，如果没有重名，则super、this以及直接访问都是一样的。

　　在子类中使用：直接访问、this、super三者的区别：

直接访问和this：

　　1、先找本类，本类有，则调用。

　　2、本类没有，找父类（如果有且可以调用，则调用；如果有但是不能调用，则报错）。

　　3、如果父类没有，则继续往上找，直到object类。一直没有找到，提示不存在。

　　super：

　　1、直接找父类，不找本类。其余规则如上。

class Computer {
private String cpu;
private int memory;
private int disk;
public int num = 12;

public Computer(String cpu, int memory, int disk) {
this.cpu = cpu;
this.memory = memory;
this.disk = disk;
}
}

class NotePad extends Computer {
private String color;
public int num = 1;

public void test() {
System.out.println(num); // 1
System.out.println(this.num); // 1
System.out.println(super.num); // 12
}
}

　　c、super访问不限于直接父类，如果爷爷类也有同名成员，也可以使用super去访问。如果多个上级类都有同名成员，遵循就近原则。

继承方法重写：

1、定义：方法覆盖（重写）就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么就是子类方法覆盖了父类方法。

2、满足条件：

　　a、子类的方法的形参列表、方法名称要和父类的参数方法名称完全一样。

　　b、子类方法的返回类型要和父类一样活着是父类返回类型的子类：如父类返回类型是object，子类是String。

　　c、子类方法不可以缩小父类方法的访问权限：public > protected > 默认 > private。

方法重写和方法重载的区别：

1、方法重载：Java中允许在同一个类中，多个同名方法的存在，到要求形参列表不一致。

2、方法重写：子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么就是子类方法覆盖了父类方法。

多态：

一、多态概述：

1、多态是继封装、继承之后，面向对象的第三大特性。

2、多态现实意义理解：

　　现实事物经常会体现出多种形态，如学生，学生是人的一种，则一个具体的同学张三既是学生也是人，即出现两种形态。

　　Java作为面向对象的语言，同样可以描述一个事物的多种形态。如Student类继承了Person类，一个Student的对象便既是Student，又是Person。

3.多态体现为父类引用变量可以指向子类对象。

Animal animal = new Dog("米奇", 23);

4.前提条件：必须有子父类继承关系。

注意：在使用多态后的父类引用变量调用方法时，会调用子类重写后的方法。

// 运行时，执行到该行的时候，animal运行类型是dog，所以是dog的eat();
animal.eat(); // 小狗吃东西

5.多态的定义与使用格式

定义格式：父类类型 变量名=new 子类类型();

6.理解:

　　多态是同一个行为具有多个不同表现形式或形态的能力。

　　多态就是同一个接口，使用不同的实例而执行不同操作。

二、多态成员特点：

1、成员属性（变量）：

　　属性没有重写之说，属性的值看编译类型：直接调用的就是animal的属性的值：

Animal animal = new Dog("米奇", 23); // 编译类型是animal

System.out.println(animal.num); // 父类的num

2、成员方法：

成员方法有重写，如果重写，调用的就是子类方法，无重写，调用父类：

animal.say(); // 子类重写父类say方法，调用的是子类

public static void main(String[] args) {
// animal 编译类型是 Animal，运行类型是 dog
Animal animal = new Dog("米奇", 23);
// 运行时，执行到该行的时候，animal运行类型是dog，所以是dog的eat();

　　// 如果子类没有重写父类的方法，那么调用的就是父类的方法
animal.AnimalEat(); // 父类的方法：动物吃东西

　　// 如果子类重写了父类的方法，那么调用的就是子类的方法。
　　 animal.say(); // 子类的方法：小狗唱歌

System.out.println(animal.num);  // 父类的值：10  

}

三、多态的转型 ：向上转型和向下转型

1、向上转型：

　　父类的引用指向了子类的对象（多态本身就是向上转型过的过程）
　　使用格式：父类类型 变量名=new 子类类型();

Animal animal = new Dog("米奇", 23);

　 特点：

　　　　a、可以调用父类的所有成员（变量和方法），但是需要遵循访问权限。

　　　　b、不能调用子类的特有成员，可以调用子类的重写方法：因为在编译阶段，能调用哪些成员，有编译类型决定（编译看左边）。

　　　　为什么不能调用子类成员？

　　　　　　因为编译的时候就不通过，编译就会报错。

总结：向上转型    父类类型 变量名=new 子类类型();

　　a、编译的时候只能调用父类方法。

Animal animal = new Dog("米奇", 23);

animal.AnimalEat(); // 父类方法

animal.DogEat(); // 子类方法报错

　　b、运行的时候还是先从子类找该方法，如果有就调用，没有往上找。

（就是如果子类重写了父类方法，运行的时候就会调用子类，没有重写就不会调用子类方法，调用父类方法）

// 子类重写了父类say方法：编译时调用的是父类方法，但是实际运行时调用的是子类重写的say方法
animal.say(); // 小狗唱歌

2、向下转型：

1、前提：如果要向下转型必须先向上转型：

Animal animal = new Dog;

2、语法：子类类型 引用名  = (子类类型)　父类引用；

Dog dog = (Dog) animal;

3、注意点：

　　a、只能强转父类引用，不能强转父类对象。

Dog dog = (Dog) Animal; // 错误

　　b、向下转型后，可以调用子类中所有成员。

dog.DogEat();

instanceof：比较操作符

1、意义：

　　1、用于判断对象的运行类型是否为某个类型 或者 为某类型的子类型。

　　2、它的作用是测试它左边的对象是否是它右边的类的实例

public class instanceOf {
public static void main(String[] args) {
BB bb = new BB();
System.out.println(bb instanceof BB); // true
System.out.println(bb instanceof AA); // true

// aa的编译类型是AA，aa的运行类型是BB  
AA aa = new BB();  
// 下面这句话意思：aa的运行类型BB 是 AA 的类或者子类吗？  
System.out.println(aa instanceof AA);  // true  
// 下面这句话意思：aa的运行类型BB 是 BB 的类或者子类吗？  
System.out.println(aa instanceof BB);  // true  

}
}

class AA {}
class BB extends AA{}

2、实际用法：

　　在写程序的时候，如果要进行类型转换，我们最好使用instanceof运算符来判断

它左边的对象是否是它右边的类的实例，再进行强制转换。

动态绑定：

1、当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定。

public class DynamicBinding {
public static void main(String[] args) {
// father的编译类型：Father；father的运行类型：Son。
Father father = new Son();
// 调用方法时，会和运行类型绑定，cal方法会调用子类的sum方法。
System.out.println(father.cal()); // 40
}
}

class Father{
int num = 10;

public int cal() {
return sum() + 20;
}

public int sum() {
return num + 10;
}
}

class Son extends Father{
int num = 20;

public int sum() {
return num;
}

public int cal() {
return num + 20;
}
}

2、当调用对象属性的时候，没有动态绑定，哪里声明，哪里使用。

多态参数：

方法的形参类型为父类类型，实参为子类类型：

public class Main {
public static void main(String[] args) {
Ordinary tom = new Ordinary("tom", 2500);
Manager milan = new Manager("milan", 5000, 200000);
Main main = new Main();
**main.showEmpAnnual(tom);
main.showEmpAnnual(milan);

main.testWork(tom);  
main.testWork(milan);**

}

// 方法：输出普通员工和经理的工资
public void showEmpAnnual(Employee e) {
System.out.println(e.getAnnual());
}

// 添加一个方法：如果是普通员工，则调用work方法，如果是经理，则调用manage方法
// 使用 类型判断 + 向下转型 这里 e 就是 Employee的引用类型 Employee e =
public void testWork(Employee e) {
if (e instanceof Ordinary) {
/*
下面这句相当于：
Ordinary ordinary = (Ordinary)e;
ordinary.work;
的简写
* */
((Ordinary) e).work(); // 向下转型

} else if (e instanceof Manager) {  
  ((Manager) e).manage();  
} else {  
  System.out.println("不处理");  
}  

}
}

toString方法：

1、他是object类下面的一个方法，因此所有的类都可以使用。

2、默认返回：全类名（包名 + 类名）+ @ + 十六进制哈希值。

3、当直接输出一个对象时，默认会调用tostring方法。

public class ToString {
public static void main(String[] args) {
AA aa = new AA();
System.out.println(aa.toString()); // com.homework.AA@776ec8df

System.out.println(aa);  // com.homework.AA@776ec8df

}
}

class AA {}

4、子类往往会重写tostring方法，用于返回对象的属性信息

public class ToString {
public static void main(String[] args) {
AA aa = new AA("mary", 23);
System.out.println(aa.toString()); // AA{name='mary', age=23}

System.out.println(aa);  // AA{name='mary', age=23}

}
}

class AA {
String name;
int age;

public AA(String name, int age) {
this.name = name;
this.age = age;
}

@Override
public String toString() {
return "AA{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}