Java面向对象三大特性（继承，封装，多态）

封装

首先是抽象，把事物抽象成一个类，其次才是封装，将事物拥有的属性和动作隐藏起来，只保留特定的方法与外界联系
封装符合面向对象设计原则的第一条：单一性原则，一个类把自己该做的事情封装起来，而不是暴露给其他类去处理，当内部的逻辑发生变化时，外部调用不用因此而修改，他们只调用开放的接口，而不用去关心内部的实现

public class Human{
    private int age;
    private String name;

    public int getAge(){
        return age;
    }
 
    public void setAge( int age ) throws Exception{
        //封装age的检验逻辑，而不是暴露给每个调用者去处理
        if( age > 120 ){
            throw new Exception( "Invalid value of age" );
        }
        this.age = age;
    }
 
    public String getName(){
        return name;
    }
 
    public void setName( String name ){
        this.name = name;
    }

继承

Java的类可以分为三类：

类：使用class定义，没有抽象方法
抽象类：使用abstract class定义，可以有也可以没有抽象方法
接口：使用inerface定义，只能有抽象方法

在这三个类型之间存在如下关系：

类可以extends：类、抽象类（必须实现所有抽象方法），但只能extends一个，可以implements多个接口（必须实现所有接口方法）
抽象类可以extends：类，抽象类（可全部、部分、或者完全不实现父类抽象方法），可以implements多个接口（可全部、部分、或者完全不实现接口方法）
接口能extends多个接口

继承以后子类可以得到什么:

子类拥有父类非private的属性和方法(私有无法访问)
子类可以添加自己的方法和属性，即对父类进行扩展
子类可以重新定义父类的方法，即多态里面的覆盖，后面会详述

关于构造函数:

构造函数不能被继承，子类可以通过super()显示调用父类的构造函数
创建子类时，编译器会自动调用父类的无参构造函数
如果父类没有定义无参构造函数，子类必须在构造函数的第一行代码使用super()显示调用

多态

方法的唯一性标识

一个方法可以由：修饰符如public、static+返回值+方法名+参数+throw的异常 5部分构成
其中只有方法名和参数是唯一性标识，意即只要方法名和参数相同那他们就是相同的方法
所谓参数相同，是指参数的个数，类型，顺序一致，其中任何一项不同都是不同的方法

什么是重载

重载是指一个类里面（包括父类的方法）存在方法名相同，但是参数不一样的方法，参数不一样可以是不同的参数个数、类型或顺序
如果仅仅是修饰符、返回值、throw的异常不同，那这是2个相同的方法，编译都通不过，更不要说重载了

//重载的例子
public class Programmer extends Human{
    public void coding() throws Exception{
        
    }
    public void coding( String langType ){
        
    }
    public String coding( String langType, String project ){
        return "";
    }

错误示例

//这不是重载，而是三个相同的方法，编译报错
public class Programmer extends Human{
    public void coding() throws Exception{
        
    }
    public void coding(){
        
    }
    public String coding(){
        return "";
    }
}

何谓覆盖/重写

覆盖描述存在继承关系时子类的一种行为
子类中存在和父类相同的方法即为覆盖，何谓相同方法请牢记前面的描述，方法名和参数相同，包括参数个数、类型、顺序

public class Human{
    public void coding( String langType ){
        
    }
}

// ===================================
public class Programmer extends Human{
    //此方法为覆盖/重写
    public void coding( String langType ){
 
    }
    //此方法为上面方法的重载
    public void coding( String langType, String project){
        
    }
}

覆盖/重写的规则：（两同两小一大原则）

子类不能覆盖父类private的方法，private对子类不可见，如果子类定义了一个和父类private方法相同的方法，实为新增方法
重写方法的修饰符一定要大于被重写方法的修饰符(public > protected > default > private)
重写抛出的异常需与父类相同或是父类异常的子类，或者重写方法干脆不写throws
重写方法的返回值必须与被重写方法一致，否则编译报错
静态方法不能被重写为非静态方法，否则编译出错

class Human{
    public void showName(){
        System.out.println( "I am Human" );
    }
}
 
//继承关系
class Doctor extends Human{
    //方法重写
    public void showName(){
        System.out.println( "I am Doctor" );
    }
}
 
class Programmer extends Human{
    public void showName(){
        System.out.println( "I am Programmer" );
    }
}
 
public class Test{
    //向上转型
    public Human humanFactory( String humanType ){
        if( "doctor".equals( humanType ) ){
            return new Doctor();
        }
        if( "programmer".equals( humanType ) ){
            return new Programmer();
        }
        return new Human();
    }
 
    public static void main( String args[] ){
        Test test = new Test();
        Human human = test.humanFactory( "doctor" );
        human.showName();//Output:I am Doctor
        human = test.humanFactory( "programmer" );
        human.showName();//Output:I am Programmer
        //一个接口的方法，表现出不同的形态，意即为多态也
    }
}

向上转型的缺憾

只能调用父类中定义的属性和方法，对于子类中的方法和属性它就望尘莫及了，必须强转成子类类型
当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法，但是它仍然要根据继承链中方法调用的优先级来确认方法，该优先级为：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)

class Human {
    public void fun1() {
        System.out.println("Human fun1");
        // 该方法在Programmer中被重写，实际调用的是被引用变量Programmer中的fun2()方法
        fun2();
    }
 
    public void fun2() {
        System.out.println("Human fun2");
    }
}
 
class Programmer extends Human {
    // 重载
    public void fun1(String name) {
        System.out.println("Programmer's fun1");
    }
    // 重写
    public void fun2() {
        System.out.println("Programmer's fun2");
    }
}
 
public class Test {
    public static void main(String[] args) {
        // 向上转型
        Human human = new Programmer();
        // 调用父类中的fun1()方法
        human.fun1();
    }
}

Programmer中的fun1(String name) 和Human中的fun1()，只是方法名相同但参数不一样，所以是重载关系
Programmer中的fun2()和Human中的fun2()是相同的方法，即Programmer重写了Human的fun2()方法
把Programmer的对象向上转型赋值个Human后，human.fun1()会调用父类中的fun1()方法，子类的fun1(String name)是不同的方法
在human的fun1()中又调用了fun2()方法，该方法在Programmer中被重写，实际调用的是被引用变量Programmer中的fun2()方法

面试题

public class A {    
    public int a = 0;
    public void fun(){
        System.out.println("-----A-----");
    }
}
 
public class B extends A{
    public int a = 1;
    public void fun(){
        System.out.println("-----B-----");
    }
 
public static void main(String[] args){
        A classA = new B();     
        System.out.println(classA.a);
        classA.fun();
    }

答案

0
-----B-----

/*
 java中变量不能重写，可以按如下口诀记忆：
 变量多态看左边， 
 方法多态看右边， 
 静态多态看左边。
*/

Java三大特性（继承，封装，多态）

Java面向对象三大特性（继承，封装，多态）

封装

继承

多态

猜你喜欢