封装、继承、重载、重写、多态

　　有时候，代码写的不少，但有些术语却总是记得不太清楚；有些原理，明明经常用到，但却不太会描述。既然如此，那就记录下来，印象不深的时候再来看看。

　　1.封装：把对象的属性、操作（或业务）结合为一个整体（class），并尽可能得隐藏内部实现细节，使得对数据的访问只能通过已定义的接口。

public class Person {
    private String name = "张三";
    
    private int age = 18;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
    public void eat(){
        System.out.println("人要吃东西。");
    }
    
}

　　上述代码中，把姓名、年龄属性和吃饭行为都封装到person类中的做法，叫做是封装。

 

　　2.继承：从已有的类中派生出新的类，新的类能吸收已有类中的属性与方法，并能拓展新的能力。被继承的类称之为“父类”或“基类”，派生出的新类称之为该类的子类。

　　   重写：子类对从父类继承而来的方法进行修改，返回值和形参都不能改变（可以用注解@override来校验重写是否成功），子类重写的方法不属于新增的方法，重写又叫做覆盖。特别注意，父类的成员变量和静态变量不会被重写，仅仅会被隐藏，被隐藏的变量无法被访问。

public class Son extends Person {
    //私有属性无法被继承
    private int age = 1;
    
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
    //重写父类方法
    @Override
    public void eat() {
        System.out.println(this.getAge() + "岁的儿子" + this.getName() + "说:爸爸,我饿。");
    }
}

public class Test {
    
    //测试方法1
    @org.junit.Test
    public void test1() throws Exception {
        Son son = new Son();
        son.eat();
    }

}

执行结果：1岁的儿子张三说:爸爸,我饿。

　　上述代码中，父类name属性被子类继承，所以执行结果中，儿子也叫做张三。而eat()方法被重写，子类对象调用的是重写后的eat()方法。

 

　　3.重载：在一个类中存在多个方法名称相同，但参数签名不同（参数的个数或者类型不同）。（修饰符、返回值类型可以相同也可以不同）

public class Reload {
    
    public static void reload(){
        System.out.println("无参重载方法。");
    }
    
    public void reload(String s){
        System.out.println("string参数重载方法。");
    }
    
    public void reload(String s, int i){
        System.out.println("string,int参数重载方法。");
    }
    
    protected String reload(int i){
        System.out.println("int参数重载方法。");
        return "";
    }
}

public class Test {
    
    @org.junit.Test
    public void test2() throws Exception {
        Reload reload = new Reload();
        reload.reload();
        reload.reload("");
        reload.reload("",1);
        reload.reload(1);
    }

}

执行结果：
    无参重载方法。
    string参数重载方法。
    string,int参数重载方法。
    int参数重载方法。

 

　　4.多态：允许不同类的对象对同一消息做出响应。即同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。这也意味着一个对象有着多重特征，可以在特定的情况下，表现不同的状态，从而对应着不同的属性和方法。

　　多态的实现方式：接口实现，继承父类进行方法重写，同一个类中进行方法重载。

public class Person {
    private String name = "张三";
    
    private int age = 18;
    
    public Person(){
        System.out.println("父类的无参构造器：" + this.getName() + "今年" + this.getAge() +"岁。");
        this.eat();
    }
    
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
    public void eat(){
        System.out.println("人要吃东西。");
    }
    
}

public class Son extends Person {
    //私有属性无法被继承，因为此变量名在父类中存在，故父类中此变量将被隐藏
    private int age = 1;
    
    public static String addr = "abc";
    
    public Son(){
        //在执行子类的构造方法之前，必定先调用父类的构造器,若无显示，则默认调用super()
        //默认：super();
        System.out.println("子类的无参构造器：" + this.getName() + "今年" + this.getAge() +"岁。");
    }
    
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
    //重写父类方法
    @Override
    public void eat() {
        System.out.println(this.getAge() + "岁的儿子" + this.getName() + "说:爸爸,我饿。");
    }
}

public class Test {
    @org.junit.Test
    public void test3() throws Exception {
        Person person = new Son();
        person.eat();
        
    }
}

执行结果：

　　父类的无参构造器：张三今年0岁。
　　0岁的儿子张三说:爸爸,我饿。
　　子类的无参构造器：张三今年1岁。
　　1岁的儿子张三说:爸爸,我饿。

　　定义父类引用指向子类对象，在创建子类对象时，步骤：

1首先会隐式调用父类无参构造器，于是先打印了“父类的无参构造器：张三今年0岁”。而为何是0岁而不是18岁的原因，是子类中存在age变量与父类同名，故父类的age变量被隐藏。2而在父类构造器中调用了this.eat()，实际调用的还是子类重写后的方法（毕竟调用对象都是子类对象，仅仅引用类型为父类而已），3接着super()构造器执行完成（作用是初始化父类变量和方法等），开始执行子类构造器（先初始化子类变量），4调用子类eat()方法。

转载于:https://www.cnblogs.com/wangxiaotiao/p/8531919.html