Java中封装、继承、多态

1. Java中封装

封装：就是隐藏对象的属性和实现细节，仅对外提供公共访问方式。

隐藏类的实现细节，让使用者只能通过程序员规定的方法来访问数据，可以方便的加入存取控制语句，限制不合理操作。

1. 数据封装：保护数据成员，不让类以外的程序直接访问或修改，只能通过提供的公共的接口访问。

2. 方法封装：方法的细节对用户是隐藏的，只要接口不变，内容的修改不会影响到外部的调用者。

public class Test {
    public int add(int a, int b){
        return a + b;
    }
    public void output(){
        System.out.println("Hello World");
    }
    public void method(int a){
        if(a < 10){
            return;
        }
        System.out.println("Welcome!!");
    }
    public static void main(String[] args){
        Test test = new Test();
        int x = 8;
        int y = 3;
        int a = test.add(x, y);
        System.out.println(a);
		
        test.output();
        int m = 15;
        test.method(m);
    }
}
11
Welcome!!

2. Java中继承

继承：继承是从已有的类中派生出新的类称为子类，子类继承父类的数据属性和行为，并能根据自己的需求扩展出新的行为。

通过extends关键字来实现，是实现代码重用的重要手段之一。Java是单继承，每个类只能有一个父类。所有类都是Object类的子类。

继承总结：
a) 父类有的，子类也有
b) 父类没有的，子类可以增加
c) 父类有的，子类可以改变

1. 属性
    父类有，子类没有（父类调用父类的属性，子类调用父类的属性）
    父类有，子类有（父类调用父类的属性，子类调用子类的属性）
    父类没有，子类有（父类无法调用属性，子类调用子类的属性）
    父类没有，子类没有（父类无法调用属性，子类无法调用属性）
(1) 父类有属性就用父类属性，没有就无法调用属性。
(2) 子类有属性就用子类属性，子类没有属性父类有就用父类的，子类没有属性父类也没有属性就无法调用属性。

2.方法
1) 构造方法(空)
    父类有，子类没有（父类调用父类的构造方法，子类调用父类的构造方法、子类默认的构造方法）
    父类有，子类有（父类调用父类的构造方法，子类调用父类、子类的构造方法）
    父类没有，子类有（父类调用父类默认的构造方法，子类调用父类默认的构造方法、子类的构造方法）
    父类没有，子类没有（父类调用父类默认的构造方法，子类调用父类默认的构造方法、子类默认的构造方法）
(1) 父类有构造方法就用父类的构造方法，没有就使用父类默认的构造方法。
(2) 父类有构造方法就用父类的构造方法，没有就使用父类默认的构造方法。子类有构造方法就用子类的构造方法，没有就使用子类默认的构造方法。
注意：这种情况是在没有其他构造方法的情况下。
2) 构造方法(非空)
3) 一般方法
    父类有，子类没有（父类调用父类的一般方法，子类调用父类的一般方法）
    父类有，子类有（父类调用父类的一般方法，子类调用子类的一般方法）
    父类没有，子类有（父类无法调用一般方法，子类调用子类的一般方法）
    父类没有，子类没有（父类无法调用一般方法，子类无法调用一般方法）
(1) 父类有属性就用父类一般方法，没有就无法调用一般方法。
(2) 子类有属性就用子类一般方法，子类没有属性父类有就用父类的，子类没有一般方法父类也没有一般方法就无法调用一般方法。

public class InheritenceTest {
    public static void main(String[] args){
        Dog dog = new Dog();
        dog.run();
    }	
}
class Animal{
    public void run(){
        System.out.println("animal is running");
    }
}
class Dog extends Animal{
    public void run(){
        System.out.println("dog is running");
        super.run();
    }
}
dog is running
animal is running

3. Java中多态

多态：指允许不同的对象对同一消息做出相应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。

“一个接口，多种方法”，同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。重载(overload)和重写(override)是实现多态的两种主要方式。

多态的三个条件：
a) 继承的存在(继承是多态的基础,没有继承就没有多态)
b) 子类重写父类的方法(多态下调用子类重写的方法)
c) 父类引用变量指向子类对象(子类到父类的类型转换)

实现多态：
a) 接口多态性
b) 继承多态性
c) 通过抽象类实现的多态性

public class PolyTest {
    public void run(Car car){
        car.run();
    }
    public static void main(String[] args){
        PolyTest test = new PolyTest();
        Car car = new BMW();
        test.run(car);
        QQ qq = new QQ();
        test.run(qq);
    }
}
class Car{
    public void run(){
        System.out.println("car is running");
    }
}
class BMW extends Car{
    public void run(){
        System.out.println("BMW is running");
    }
}
class QQ extends Car{
    public void run(){
        System.out.println("QQ is running");
    }
}
BMW is running
QQ is running

Java面向对象的三个特性：封装、继承、多态。(如果说四种就加一种：抽象)