Java基础(一) | @小白 封装 继承 多态

课堂的时间所剩无几，最后的复习阶段，实现Java的进阶与提高，基础知识永远是王道，学而时习之，不亦乐乎。今天带来的三大概念，封装、继承和多态，简述自己的浅薄认识，不足之处，请见谅。

一、封装

• 概念
  封装，将抽象数据类型的数据和对数据的操作包装起来。正如我们每个家庭的室内装修，有温馨、甜美、适用等多种风格。家庭的四面厚厚的墙，就是抵挡风寒的包装。假如墙面严严实实，密不透风，再美的室内风光，别人也无从观赏，且不失去它的意义。对象的封装，会提供外界访问的不同的接口，就像家里面的全景玻璃幕墙，阁楼天窗等。
• 作用
  封装可以减少耦合，实现信息隐藏；可以方便的改变类的内部结构；实现成员的精确控制；（参照下面代码）

public class Person {
    protected String name;
    protected int age;
    //1:female 0:male
    private int sex;
    
    public Person(String name,int age,int sex){
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    /**
     * @method getAge
     * @desc 实现age从int类型转换为String类型
     * @return String
     */
    public String getAge() {
        return String.valueOf(age);
    }
    /**
     * @method setAge
     * @desc 对年龄范围进行控制
     * @return void
     */
    public void setAge(int age) {
        if (age < 0 || age > 110) {
            System.out.println("The age input is wrong!");
        } else {
            this.age = age;
        }
    }
    /**
     * @method getSexName
     * @desc 实现性别的显示输出
     * @return String
     */
    public String getSexName() {
        if(this.sex != 0 || this.sex != 1){
            return null;
        }
        return this.sex == 1 ? "male" : "female";
    }
    
    public void setSex(int sex) {
        this.sex = sex;
    }   
}

二、继承

• 概念
  继承，描述的是"is-a"的关系，即若A是B，则A可以继承于B，如猫是动物，则猫可以继承于动物，其可以实现代码复用
• 规则
  子类可以继承父类非private的属性和方法(不包含构造方法)；
  子类可以拥有自己的属性和方法，实现扩展；
  子类可以重新实现父类的方法，称为重写或者覆盖；

public class Teacher extends Person {
    //继承name和age属性，sex不继承，Teacher的属性学院
    protected String school;

    //若父类无构造方法，自动添加默认无参构造方法；
    //若父类仅有有参构造方法，子类必须显示调用父类有参构造方法
    //还有自己编写的无参构造方法 
    public Teacher(String name,int age,int sex,String school){
        //显示调用父类的构造方法
        super(name,age,sex);
        this.school = school;
    }

    //重写父类的setAge方法，实现功能扩展
    @Override
    public void setAge(int age) {
        if (this.age < 0 || this.age > 110 ) {
            System.out.println("Age is not normal");
            return ;
        } else if(this.age < 30) {
            System.out.println("The teacher is so talent");
        }
        this.age = age;
    } 
    public static void main(String[] args) {
        Person p = new Teacher("xh",23,0,"TC");
    }
}

• 向上转型
  上面谈到，继承描述的是"is-a"的关系，即可以说猫是动物，或者是老师是人，向上转型即创建老师实例，构建人的引用。上诉代码的main方法中，创建老师实例，构建人的引用，则会丢失老师的school属性和对应的方法，向上转型是学习下面的多态的关键。

• 慎用继承
  继承实质上是强耦合的关系，父类改变子类跟着变化，且父类对于子类来说，具有一定的透明度，如果不是需要向上转型，慎用继承。

三、多态

• 概念
  同一事件作用于不同的对象，产生不同的效果；
  依赖于动态绑定，判断引用类型的实际类型调用其相应的方法；

• 三要素
  继承：存在继承关系，必须存在父类和子类；
  向上转型：父类引用指向子类对象，即上文中人指向老师；
  重写：子类对父类方法实现重写，即上文中setAge()方法；

    public class A {  
        public String show(D obj) {  
            return ("A and D");  
        }  
        public String show(A obj) {  
            return ("A and A");  
        }   
    }     
    public class B extends A{  
        public String show(B obj){  
            return ("B and B");  
        }      
        public String show(A obj){  
            return ("B and A");  
        }   
    }  
    public class C extends B{  
    }  
    public class D extends B{  
    }  
      
    public class Test {  
        public static void main(String[] args) {  
            A a1 = new A();  
            A a2 = new B();  
            B b = new B();  
            C c = new C();  
            D d = new D();  
              
            System.out.println("1--" + a1.show(b));  // 1--A and A
            System.out.println("2--" + a1.show(c));  // 2--A and A
            System.out.println("3--" + a1.show(d));  // 3--A and D
            System.out.println("4--" + a2.show(b));  // 4--B and A
            System.out.println("5--" + a2.show(c));  // 5--B and A
            System.out.println("6--" + a2.show(d));  // 6--A and D
            System.out.println("7--" + b.show(b));  // 7--B and B
            System.out.println("8--" + b.show(c));  // 8-- B and B
            System.out.println("9--" + b.show(d));  // 9-- A and D
        }  
    }  
// 此处的分析，应该结合继承链中方法调用和多态结合来看；
// 继承链方法调用 this.show(o) super.show(o) this.show((super)o) super.show((super)o) 此处的this以引用类型为主
// 上一步确定好方法后，考虑多态的使用原则，使用实际类型的方法

三大概念的认识，到这里先告一段落。
学如逆水行舟，不进则退。珍惜为数不多的校园生活吧！