面向对象编程语言的基本特征（封装，继承，多态）

一、封装

1、封装在java语法中使用private关键字，来修饰方法和字段。被private关键字修饰，只能在当前类中使用，相当于把这个方法或字段保护起来了。

2、如果其他类要访问被封装的字段，就要通过其提供的get();和set();方法进行访问。

 封装的优点：1、安全。

                       2、对类的调用者来说，对类的使用成本降低了。

二、继承 

将不同类的共性进行抽取，放在一个类中，其他类可使用extends关键字来继承这个类并使用共性。比如：类B extends A。则称A为 

注意：1、 在Java语言中，只能通过extends来继承一个类，不能继承多个类，属于单继承。

           2、子类会继承父类所有public的字段和方法。对于父类被private修饰的字段和方法，                  子类虽有继承，但是是无法直接访问的。

           3 、子类的实例中，也包含着父类的实例，可使用super关键字得到父类实例的引用。

                 super,data   //    访问父类的成员变量                                                                                         super.func()   //   访问父类的成员变量                                                                                       super()           //   访问父类的成员构造方法

                 注意（super关键字在子类对象内部指代其父类对象的引用）

子类要构造对象，先要帮助父类对象进行构造，即super()父类的构造方法，并且所有的构造对象都要通过构造方法来实现（即要new 就要调用构造方法）。

注意：1、若类中没写构造方法，编译器会自动构造一个不带参数的构造方法。            

           2、子类构造方法中默认第一行调用super()，即调用父类的无参构造。若想要调用父                     类的有参构造方法，必须手动调用super(args)。

class Animal{
    public String name;
    public int age;

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

class Dog extends Animal{

    public Dog(String name, int age) {
        super(name, age);
    }

}

 三、多态

 1、向上转型：将子类对象(引用)给父类，即父类引用，引用了子类对象。                                     注意（向上转型之后，只能通过父类的引用来访问父类自己特有的属性和方法，不能访                    问子类自己特有的属性和方法）   

class Animal{
    public String name;
    public int age;

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

class Cat extends Animal{

    public Cat(String name, int age) {
        super(name, age);
    }
}

public class TextDemo2 {
    public static void main(String[] args) {
        Cat cat = new Cat("咪咪",3);
        Animal animal = cat;  //向上转型
    }
}

 2、运行时绑定                                                                                                                                发生的条件【① 向上转型 。②通过父类引用，调用父类和子类的同名覆盖(也叫重写/覆                             写)方法，此时会发生运行时绑定。】

3、多态（继承是前提）：父类引用，引用子类对象，通过父类引用调用父类和子类同名的覆盖方法。此时，如果父类引用，引用的子类对象不一样，调用这个重写的方法表现的行为也不一样。

4、重写（父类与子类中）

     ①方法名相同

     ②方法的参数列表相同（个数和类型）

     ③方法的返回值相同

    注意（a、静态方法是不可以重写的。                                                                                                 b、被private修饰的方法也不可以被重写。                                                                               c、子类的访问权限要大于或等于父类的访问权限                                                                     d、如果一个方法被final修饰，这个方法也不能重写。

      重载（同一类中）

      ①方法名相同

      ②方法的参数列表不同（个数和类型）

      ③返回值不做要求

class Shape {
    public void draw() {

    }
}
class Cycle extends Shape {
    @Override
    public void draw() {   //重写
        System.out.println("●");
    }
}
class Rect extends Shape {
    @Override
    public void draw() {   //重写
        System.out.println("矩形");
    }
}

public class TextDemo3 {

    public static void drawMap(Shape shape) {
        shape.draw();
    }
    public static void main(String[] args) {
        drawMap(new Cycle());
        drawMap(new Rect());
    }
}

运行结果 

 

 四、三者的优点

 封装：安全；减少类调用者的成本（调用者不需要知道类的细节）

 继承：代码可以进行重用，减少冗余。

 多态：1、进一步减少类的调用者对类的使用成本（调用者连类的类型都不需要知道，只知                   道这个对象具有某个方法即可。）       

            2、能够降低代码的“圈复杂度”，避免使用大量的if-else。

            3、可扩展能力更强。

 补：

 1、super与this的区别

super与this的区别

区别	this	super
概念	访问本类中的属性和方法	由子类访问父类中的属性和方法
查找范围	先查找本类，如果本类没有，就调用父类	不查找本类，直接调用父类
	表示当前对象的引用	表示父类对象的引用