一文带你理解java的三大特性

废话不多说，直接说结果，是继承，封装，多态。

1、看一下百度百科的概念
封装，即隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别；将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。在电子方面，封装是指把硅片上的电路管脚，用导线接引到外部接头处，以便与其它器件连接。
2、这个概念没什么好说的，封装也好理解。
我们编写的类就是我们进行封装的过程，将数据进行抽象，java是面向对象语言，我们把数据抽象后，将世间的万物都化为对象【也就是对某一个事情的封装的具体实例】，然后后续用它的这个对象完成一系的操作的过程。

3、几种修饰符

• private：对本类可见
• public：对外部完全可以见
• protected：对本包和所有子类可见
• 不加任何修饰符：对默认

子类继承父类的方法,通过继承父类，获得父类的所有方法和属性，从而简化代码，提高效率。【说话不太好理解】java里面不能像C++里面那样多继承的概念，使用extends实现的继承，取代了里面的“:”来实现继承。虽然无法实现多继承，看似java比C++不足，但是java里面有接口的概念弥补了这不份不足【后话】

看代码：hello类继承了A

• A类我们叫做基类，超类，父类
• hello类我们叫做子类，派生类或孩子类
• hello获得了A中的所有方法

class A {
    private int a;

    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }
}
class hello extends A {
    
}

使用了super进行向上编写

class A {
    private int a;

    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }
}
class hello extends A {
	private int b;
    public hello(int a,int b) {
		super(a);
		this.b = b;
	}
}

super的用法总结

• 它可以在构造器里面上面那种使用
• 二是它去调用父类中的方法【比如下面的代码】

class A {
    private int a;

    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }
}
class hello extends A {
    private int b;

    @Override
    public int getA() {
        return super.getA();
    }

    @Override
    public void setA(int a) {
        super.setA(a);
    }
}

答案先搞出来，我们的this也有两种用法：一是隐含参数的调用，二是调用该类的构造器

class hello extends A {
    private int b;
    private int c;

    public hello() {
        
    }

    //调用我们的参数
    public hello(int b) {
        this.b = b;
        this.toString();
    }
    
    //方法的调用
    public hello(int b,int c) {
        this(b);
        this.c = c;
    }

    @Override
    public String toString() {
        return "hello{" +
                "b=" + b +
                ", c=" + c +
                '}';
    }
}

好啦：本文的重点来了，多态

首先看它的概念：大致的意思是一个对象的实例，可以指向多个类。【太抽象了，不能理解，我也不理解这句话，啥呀】

看代码：下面就是多态

class A {
    private int a;
    
    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }

    public int getNum() {
        return this.a;
    }
}

class hello extends A {
    private int b = 3;

    @Override
    public int getNum() {
        return super.getA() + b;
    }
}


class hello2 extends A {
    private int b = 4;

    @Override
    public int getNum() {
        return super.getA() + b;
    }
}

这啥呀：A的对象可以指向hello和hello1的现象，包括了对象a和a1的多态，和getNum的多态。叫多态【大概是这么个意思，但是多态不止这么一点】

那多态可以分为哪些呢？

1、对象的多态

• 向上转型【这个你可以随便转，但是接下来要讲的向下转尽量不要用】
  

• 向下转型
  

2、方法的覆盖和重写

• 覆盖很好理解，就是我们刚刚编写的getNum方法

class hello extends A {
    private int b = 3;

    @Override
    public int getNum() {
        return super.getA() + b;
    }
}

• 重写也好理解：也就是方法同名，参数不同名的情况
  

• 可以把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程。
• 统一调用标准，一切向父类看齐。
• 提高了程序的扩展性和可维护性。
• 特别是在后续接口【也可以理解为一种特殊的继承关系】讲解了之后，你会有如同大意的变化，接口定义标准，大家都按着这个标准来搞。