Java三大特性：封装、继承、多态

封装

1. 定义

利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体，数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外部发生联系。系统的其他对象只能通过包裹在数据外面的已经授权的操作来与这个封装的对象进行交流和交互。也就是说用户是无需知道对象内部的细节（当然也无从知道），但可以通过该对象对外的提供的接口来访问该对象。

2. 优点

1. 良好的封装能够减少耦合。
2. 类内部的结构可以自由修改。
3. 可以对成员变量进行更精确的控制。
4. 隐藏信息，实现细节。

3. 实例

public class Person{
    //把成员变量私有化
    private String name;
    private int age;
​	
	//提供公共的setter()和getter()方法，外部进行赋值取值
    public int getAge(){
    	return age;
    }
​
    public String getName(){
    	return name;
    }
​
    public void setAge(int age){
    	//this指明前面的age为成员变量的age，后面的age为形参的age
    	this.age = age;
    }
​
    public void setName(String name){
    	this.name = name;
    }
}

/**
* 封装的好处
*/
public class Person{
    private String name;
    //成员变量age的类型由int变为String
    private String age;
​
    public int getAge(){
    	return age;
    }
​
    public String getName(){
    	return name;
    }
​
    public void setAge(int age){
   		//外部调用了setter()方法的无需作出修改，只需在这里修改setter()方法
    	this.age = String.valueOf(age);
    }
​
    public void setName(String name){
    	this.name = name;
    }
}

java提高篇(一)-----理解java的三大特性之封装

继承

1. 定义

继承是类与类之间的关系，与现实世界中的继承（例如儿子继承父亲财产）类似。继承可以理解为一个类从另一个类获取方法和属性的过程。如果类B继承于类A，那么B就拥有A的方法和属性。

2. 实现

class SuperClass{}
class SubClass extends SuperClass{}

3. 优缺点

（1）子类自动拥有了父类的非私有的成员，子类也可以有自己的成员。
（2）提高了代码的互用性和扩展性。
（3）耦合性太高，不利于开发原则：高内聚低耦合。
（4）java中只支持单继承。

4. 知识点

（1）继承会使子类继承父类的特性和方法，即父类有的子类也有。
（2）继承的关键字是 extends，当子类继承父类时，子类可以通过 super 调用父类的构造方法、域和方法。
（3）当子类构造方法没有调用父类构造方法时，会隐式地调用 super()，当父类的无参构造方法不可调用时，子类构造方法必须显示地调用父类的构造方法。
（4）当我们的成员或方法没有添加任何权限修饰符时，默认为包访问权限。
（5）声明为 private 的成员无法被子类访问；声明为 public 或 protected 的父类成员，无论子类在何处，都可以访问父类成员。
（6）父类的 private 方法无论如何都无法被重写，如果子类中出现了这个方法，它属于子类的新方法，只不过和父类的方法恰巧同名罢了，使用 @Override可以避免这种陷阱。
（7）父类中声明为 final 的方法是无法被重写的，事实上声明为 private 的成员也会被隐式地声明为 final。
（8）在重写方法时，添加注解 @Override 永远是个好习惯。
（9）重写父类方法时，重写方法的权限修饰符可以由小范围往大范围修改。
（10）抽象类被继承时，如果子类为普通类，那么子类必须为父类的抽象类方法提供定义，即重写这些抽象类方法；如果子类也为抽象类，那么可以选择不重写这些父类的抽象方法。
（11）子类对象在进行实例化前首先调用父类构造方法，再调用子类构造方法实例化子类对象。
（12）Java中不允许多重继承，但是允许多层继承。多层继承一般不会超过三层。

Java中继承的定义与使用
Java 基础之继承（一）

多态

1. 定义

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

2. 必要条件

要有子父类继承关系 extends
子类重写父类方法 @Override
父类引用指向子类对象 父类类型 变量名 = new 子类类型();

3. 实例

/**
*父类的不同子类创建的对象以父类类型声明
*不需要因为形参问题再去重新调用重写的方法
*实现的是子类重写后的内容
*/

public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 对象调用 show 方法
      show(new Dog());  // 以 Dog 对象调用 show 方法
                
      Animal a = new Cat();  // 向上转型  
      a.eat();               // 调用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下转型  
      c.work();        // 调用的是 Cat 的 work
  }  
            
    public static void show(Animal a)  {
      a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}
/*
结果：
吃鱼
抓老鼠
吃骨头
看家
吃鱼
抓老鼠
*/

4. 编译与运行

//多态成员变量：编译运行看左边
SuperClass a = new SubClass();
System.out.println(a.num);//结果是父类的num

//多态成员方法：编译看左边，运行看右边
SuperClass b = new SubClass();
System.out.println(b.show());//结果是子类的show()