JAVA面向对象三大特征

封装

封装：什么是封装，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。

通俗一点来说就是把类中的某些信息进行隐藏，从而使外部程序不能直接对这些信息进行直接的访问，只能通过类中定义的方法对这些隐藏的信息进行操作和访问。

目的：使其他类只能通过操控类中的对象来直接达到目的，不能看到具体的实现和属性，从而提高了程序的安全性和便利性。隐藏信息，实现便利。

访问权限

public class User {

    private Integer id;
    private String username;

    public Integer getId() { //对外暴露操作类属性的接口
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }
}

继承

Java中的继承是指在一个现有类（父类）的基础上在构建一个新类（子类），子类可以拥有父类的成员变量以及成员方法。目的是提高代码可用性。

super和this

重写:需要有继承关系，子类重写父类的方法!
1.方法名必须相同
2.参数列表必须相同
3.返回类型，稍微松动，允许返回被覆盖方法返回类型的子类
3.修饰符:范围可以扩大但不能缩小:public>Protected>Default>private
4.抛出的异常:范围，可以被缩小，但不能扩大; ClassNotFoundException --> Exception(大)

public class father {
    String name;
    private int id;
    public void run(){
        System.out.println("father run");
    }

    public static void main(String[] args) {
        father father = new father();
        father.run();//father run
        son son = new son();
        son.run();//song run
        son.method();// father run      son run
        System.out.println(son.name);
    }
}
class son extends father{
    public void run(){
        System.out.println("son run");
    }
    public void method(){
        super.run();//调用父类的方法
        super.name="tom";//设置父类非私有属性
//        super.id = 12; 报错，不能设置父类私有属性
        this.run();//调用本类方法
    }
}

多态

多态性：多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用不同子类型的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。
————————————————
版权声明：本文为CSDN博主「adobehu」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/huzecom/article/details/101108618

多态实现的三个重要条件：
继承、重写、父类引用指向子类对象：Parent p = new Child();

运行时多态（函数的重写）

• 向上转型时，子类如果没有重写父类中的一些方法，那么调用时调用的是父类的方法；如果子类重写了父类的方法，调用的时候调用的是子类的方法。只要是被子类覆盖的方法，在调用的时候都会调用子类的方法
• 向上转型既能调用父类的方法，也能调用子类的方法(在向上转型时，子类单独定义的方法会丢失。)
• 向下转型：向下转型之前，你必须得先向上转型
• 当父类对象引用变量引用子类对象时，被引用对象的类型决定了调用谁的成员方法，引用变量类型决定可调用的方法。如果子类没有覆盖该方法，那么会去父类中寻找*

https://blog.csdn.net/wangkaiwenjbb/article/details/80144365* https://www.cnblogs.com/moxia/p/5837546.html

/**
 * @author:LI
 * @Date:2022/8/20 19:32
 **/
public class father {
    public void run(){
        System.out.println("father run");
    }
    public void fatherMethod(){
        System.out.println("fatherMethod");
    }

    public static void main(String[] args) {
      father father = new son();//向上转型，
      father.run();// son run  父类调用子类重写的部分
      father.fatherMethod();//fatherMethod
//      father.sonMethod(); 报错，父类引用不能调用子类拓展的方法，向上转型时，子类单独定义的方法会丢失


        /** 只有向下转型之后才能调用子类特有的方法*/
        son son =(son)father;
        son.sonMethod();//sonMethod
        son.run();//son run
        son.fatherMethod();//fatherMethod

//      正常调用自己的方法和父类方法
        son son1 = new son();
        son1.fatherMethod();//fatherMethod
        son1.run();//son run

    }
}
class son extends father{

    @Override
    public void run(){
        System.out.println("son run");
    }
    public void sonMethod(){
        System.out.println("sonMethod");
    }

}

编译时多态（函数的重载）

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。
最常用的地方就是构造器的重载。
重载规则:
1、被重载的方法必须改变参数列表(参数个数或类型不一样)；
2、被重载的方法可以改变返回类型；
3、被重载的方法可以改变访问修饰符；
4、被重载的方法可以声明新的或更广的检查异常；
5、方法能够在同一个类中或者在一个子类中被重载。
6、无法以返回值类型作为重载函数的区分标准。
--------------菜鸟教程https://www.runoob.com/java/java-override-overload.html

public class overload {
    void a(){
        System.out.println("null");
    }
    int a(int a){
        System.out.println(a);
        return 123;
    }
    void a(String a){
        System.out.println(a);
    }

    public static void main(String[] args) {
        overload overload = new overload();
        overload.a();//null
        System.out.println(overload.a(11));//11 123
        overload.a("hello world");//hello world
    }
}