java面向对象的三大特性：继承，封装，多态。

继承

继承的概念：

         继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法。

---

Java中继承的注意事项

        1. Java中类只支持单继承，不支持多继承。
        2. Java中类支持多层继承。

---

继承中变量的访问特点：

        在子类方法中访问一个变量，采用的是就近原则。首先在子类局部范围找，其次在子类成员范围找。然后在父类成员范围找。如果都没有就报错(不考虑父亲的父亲…)。

---

super关键字与this关键字：

        this：代表本类对象的引用。
        super：代表父类存储空间的标识(可以理解为父类对象引用)。
        this和super的使用分别。
        成员变量：
        this.成员变量 ：访问本类成员变量。
        super.成员变量 ：访问父类成员变量。
        成员方法：
        this.成员方法 : 访问本类成员方法。
        super.成员方法 : 访问父类成员方法。
        构造方法：
        this(…) : 访问本类构造方法。
        super(…) : 访问父类构造方法。

---

继承中构造方法的访问特点

        注意：子类中所有的构造方法默认都会访问父类中无参的构造方法。

        ​子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化，原因在于，每一个子类构造方法的第一条语句默认都是：super()。

        问题：如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢？。
        1. 通过使用super关键字去显示的调用父类的带参构造方法。
        2. 在父类中自己提供一个无参构造方法（推荐！）。

案例：当父类没有无惨构造方法时 。

 解决方式一：在子类使用super关键字去显示的调用父类的带参构造方法。

解决方式二（推荐）：在父类提供无参构造方法。

---

 继承中成员方法的访问特点

        通过子类对象访问一个方法。

        1. 子类成员范围找。
        2. 父类成员范围找。
        3. 如果都没有就报错(不考虑父亲的父亲…)。

---

方法重写

方法重写概念：
        子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）。
方法重写的应用场景：
        当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

方法重写的注意事项

        1. 私有方法不能被重写(父类私有成员子类是不能继承的)。
        2. 子类方法访问权限不能更低(public > 默认 > 私有)。 

---

final关键字

   final代表最终的意思，可以修饰成员方法，成员变量，类。
   final修饰类、方法、变量的效果：

   fianl修饰类：该类不能被继承（不能有子类，但是可以有父类）。

案例：当父类被final修饰时。

---

   final修饰方法：该方法不能被重写。

案例：当方法被修饰时。

---

   final修饰变量：表明该变量是一个常量，不能再次赋值。

案例：当常量被修饰时。

---

static关键字:

 概念：static关键字是静态的意思，可以修饰【成员方法】，【成员变量】
 static修饰的特点 ：
  1. 被类的所有对象共享，这也是我们判断是否使用静态关键字的条件
  2. 可以通过类名调用当然，也可以通过对象名调用**【推荐使用类名调用】

static的访问特点：

非静态的成员方法：能访问静态的成员变量、能访问非静态的成员变量、能访问静态的成员方法、
能访问非静态的成员方法。
静态的成员方法：能访问静态的成员变量、能访问静态的成员方法，总结成一句话就是：静态成员方法只能访问静态成员。

---

继承的好处与弊端：

继承好处
          提高了代码的复用性(多个类相同的成员可以放到同一个类中)。
          提高了代码的维护性(如果方法的代码需要修改，修改一处即可)。
继承弊端
          继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性。
继承的应用场景：
           使用继承，需要考虑类与类之间是否存在is..a的关系，不能盲目使用继承。
           is..a的关系：谁是谁的一种，例如：老师和学生是人的一种，那人就是父类，学生和老师就是子类。

---

 多态

多态的概念：

同一个对象，在不同时刻表现出来的不同形态。

多态的前提：

要有继承或实现关系。
要有方法的重写。
要有父类引用指向子类对象。

---

多态中的成员访问特点：

成员变量：编译看父类，运行看父类

成员方法：编译看父类，运行看子类

---

多态中的转型:

向上转型：父类引用指向子类对象就是向上转型

向下转型：格式：子类型 对象名 = (子类型)父类引用;

代码演示：

Animal.java

 Cat.java

Demo.java 

---

 多态的好处和弊端：

好处：提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作。

弊端：不能使用子类的特有成员。

---

抽象类        

抽象类的特点：抽象类和抽象方法必须使用 abstract 关键字修饰；

抽象类的定义：
public abstract class 类名 {}

例图：Animal.java

抽象方法的定义：
public abstract void eat();

例图：Cat.java

package 博客;

public abstract class Animal {
    private int age;
    private String name;

    public Animal() {
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

注意事项：

抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类。

- 抽象类不能实例化。

抽象类如何实例化呢？参照多态的方式，通过子类对象实例化，这叫抽象类多态

- 抽象类的子类

  ​    要么重写抽象类中的所有抽象方法

  ​    要么是抽象类

---

抽象类的成员特点：

成员的特点

成员变量的特点：既可以是变量，也可以是常量。
构造方法：有空参构造方法和有参构造方法。
成员方法：有抽象方法和普通方法。

---

接口

接口的特点：

接口用关键字interface修饰；

public interface 接口名 {} 

类实现接口用implements表示
public class 类名 implements 接口名 {}
- 接口不能实例化

  ​    接口如何实例化呢？参照多态的方式，通过实现类对象实例化，这叫接口多态。

  ​    多态的形式：具体类多态，抽象类多态，接口多态。 

- 接口的子类

  ​    要么重写接口中的所有抽象方法

  ​    要么子类也是抽象类

---

接口的成员特点：

成员特点

成员变量

  ​     只能是常量
  ​     默认修饰符：public static final

构造方法

  ​    没有，因为接口主要是扩展功能的，而没有具体存在

成员方法

  ​    只能是抽象方法

  ​    默认修饰符：public abstract

---

类和接口的关系：

类与类的关系：继承关系，只能单继承，但是可以多层继承（子类继承父类，父类继承父类的父类...)。

类与接口的关系：实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口。

接口与接口的关系：继承关系，可以单继承，也可以多继承（一个接口同时继承好几个接口）。

抽象类和接口的区别:

 成员区别

       抽象类:变量,常量；有构造方法；有抽象方法,也有非抽象方法

       接口:常量；抽象方法

关系区别

        类与类"继承，单继承

        类与接口:实现，可以单实现，也可以多实现-

        接口与接口:继承，单继承，多继承

设计理念区别

        抽象类:对类抽象，包括属性、行为

        接口:对行为抽象，主要是行为

---

封装

 封装思想：

1. 封装概述
   是面向对象三大特征之一（封装，继承，多态）。
   是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的。
2. 封装原则
   将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。
   成员变量private，提供对应的getXxx()/setXxx()方法。
3. 封装好处
   通过方法来控制成员变量的操作，提高了代码的安全性。
   把代码用方法进行封装，提高了代码的复用性。

---

private关键字:

        private是一个修饰符，可以用来修饰成员（成员变量，成员方法）。

        被private修饰的成员，只能在本类进行访问，针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作。
        提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰。
        提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰 。

例图

package 博客;

public class Animal {
    private int age;
    private String name;

    public Animal() {
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package 博客;

public class Demo {
    public static void main(String[] args) {
   Animal animal=new Animal();
   animal.setAge(2);
   animal.setName("泡芙");
        System.out.println(animal.getName()+","+animal.getAge());
    }
}

---

java面向对象三大特征到这里就结束了，感谢大家的观看！