Java面向对象三大特征：封装、继承、多态

封装

在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。

封装的好处：

1. 良好的封装能够减少耦合。

2. 类内部的结构可以自由修改。

3. 可以对成员变量进行更精确的控制。

4. 隐藏信息，实现细节。

封装的步骤：

1、给成员变量加上private

2、为每一个成员变量提供getter和setter

public class Student {

    //成员变量
    private int id;
    private String name;

    //无参构造函数，如果没有写构造函数，系统默认有一个无参的构造函数
    //若写了有参的构造函数，系统就不会提供无参的构造函数了
    public Student() {
    }

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

继承：

在一个已知类A的基础上,创建新类B的过程,称之为继承
这里类A,称为父类,基类,超类,英文名SuperClass
这里类B,称为子类,派生类,英文名SubClass 

继承的格式：

继承关键字：extends

//父类
public class A{
}

//子类
public class B extends B{

}

子类继承父类后就会自动继承父类中的成员变量和成员方法

子类也可以添加自己的成员变量和成员方法

父类的构造方法子类无法继承

父类的私有成员可以继承但是无法直接调用（可以通过gettet/setter方法间接调用）

继承后的特点：

1、Java只支持单继承，可以多层继承一。个类只能有一个父类但是可以有多个子类，父类也可以有父类

2、当子类成员变量和父类同名时，调用该变量根据就近原则调用子类变量，如果想访问父类中的变量可以使用super关键字

3、当子类成员方法和父类同名时，调用该方法根据就近原则调用子类方法，可以使用super.方法名();调用父类方法

4、在子类的"任何构造方法"的"第一行",都有默认一句代码"super()",代表调用父类的无参构造 （可以手动修改为super(参数)，调用父类的有参构造函数）

 

子类继承父类后如果发现父类方法不足可以重写父类方法

方法重写（override）：在继承关系中,子类中出现了一个和父类除了方法体,其他一模一样的方法,称为方法的重写 

 

多态：

严格的定义: 同一个动作,具有不同的表现形式
不是很严格的定义:  同一个对象,具体不同的形态

##多态提高了代码的扩展性/灵活性##

多态的前提：

a.必须有继承关系或者实现关系
b.必须有方法的重写   
只有满足了以上两个前提,才有多态 

多态的体现：

父类类型的变量 指向了 子类类型的对象      Fu ff=new zi();

多态的三种写法：

​ 1，标准写法：父类类型指向子类对象，父类类型 变量名 = 子类对象。

​ 2，引申写法：间接父类类型指向子类对象，间接父类型 变量名 = 子类对象。

​ 3，引申写法：接口类型指向实现类对象，接口数据类型 变量名 = 实现类对象。

 

多态调用方法的特点：

编译阶段看父类，运行阶段看子类

//父类
public class Animal{
    public void eat(){
      
    }
}
//子类
public class Dog extends  Animal{
    @Override
    public void eat(){
      
    }
}
//测试类
public class Test{
    public static void main(String[] args){
    Animal an = new Dog();//Fu fu =new Zi();
    //调用eat()方法时，在编译阶段看父类，若父类没有eat()方法，编译不通过；******多态的弊端******
    //运行阶段看子类，运行子类的eat()方法
    an.eat();
    }
}

 

因为多态调用方法的特点，造成了多态的弊端

解决方法：向下转型

//父类
public class Animal{
    public void eat(){
      
    }
}
//子类
public class Dog extends  Animal{
    @Override
    public void eat(){
      
    }
     public void speak(){
      System.out.println("旺旺。。。。");
    }
}
//测试类
public class Test{
    public static void main(String[] args){
    Animal an = new Dog();//向上转型
    Dog d=(Dog)an;
    d.eat();
    d.speak();
    }
}