Java基础：封装、继承和多态（重写和重载）

一，重写(Overide)和重载（Overload）

：方法的重写和重载都是多态的体现。重载是编译型多态，重写是运行时多态。

1.重写:发生在继承关系中，子类继承了父类的原有方法，但在某些情况下，子类并不想继承原有的方法，对继承的方法（方法名，参数列表，返回类型和父类一致，并且子类函数的访问修饰权限不能少于父类的，若父类修饰符是public，则子类不能用protected，若父类修饰符是private，则子类无法继承）进行方法体重写。

public class A {

    public static void main(String[] args) {
        B b=new B();
        b.test();
    }
    public void test(){
        System.out.println("A");
    }
}
class B extends A{
    @Override
    public void test(){
        System.out.println("B");
    }
}
//答案：B

2.重载：发生在本类方法中，是类中多态性的表现，要求同名方法参数列表不同（参数类型，参数个数和参数顺序），返回值类型可以相同也可以不同。无法以返回值类型作为区分重载的标准。

public class A {

    public static void main(String[] args) {
        A a=new A();
        a.test(1,2);
        a.test(1);
    }
    public void test(int i,int j){
        System.out.print("A");
    }
    public void test(int i){
        System.out.print("B");
    }
}
//答案：AB

二：封装、继承和多态

1.封装：封装的核心是私有(private)。封装一般用来封装对象的属性，很少封装方法。例如下面的类A中，将属性封装，设置get和set方法来操作私有的属性。

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

    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;
    }
}

2.继承：继承就是子类继承父类的方法和属性，私有的不能被继承。Java只能单继承，父类可以有多个子类，子类只能由一个父类。子类拥有父类的非private方法，同时也可以拓展自己的方法。

3.多态：1.是继承；2有方法的重写；3父类引用指向子类对象；4编译看左边，运行看右边

三、Java设计模式：

设计模式是一套经过反复使用的代码设计经验，目的是为了重用代码，让代码更容易被他人理解，保证代码可靠性。

1.总的来说，设计模式被分为三大类：

创建型模式：共5种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式
结构型模式：共7种：适配器模式、装饰器模式、代理模式、桥接模式、外观模式、组合模式、享元模式
行为型模式：共11种：策略模式、模板方法模式、观察者模式、责任链模式、访问者模式、中介者模式、迭代器模式、命令模式、状态模式、备忘录模式、解释器模式

还有两类：并发型模式和线程池模式

2.设计模式的六大原则：

1>开闭原则： 开闭原则指的是对扩展开放，对修改关闭。在对程序进行拓展时，不能去修改原有的代码，使用抽象类或接口。

2>依赖倒转原则：依赖倒转原则是开闭原则的基础，系统面向接口编程，依赖于抽象而不依赖于具体。

3>里氏替换原则：里氏替换原则指的是任何基类出现的地方，子类一定可以出现。里氏替换原则是对开闭原则的补充，实现开闭原则的关键是抽象化，而基类与子类的继承关系就是抽象化的具体实现，所以里氏替换原则是对实现抽象化的具体步骤的规范。

4>接口隔离原则：使用多个隔离的接口比使用单个接口好，降低接口之间的耦合度和依赖。

5>迪米特原则：最少知道原则。一个类应当尽量减少与其他实体类相互作用，使得系统功能模块相对独立，降低耦合度。

6>合成复用原则：尽量使用组合/聚合的方式，而不是继承。

3.Java设计模式：创建型：单例模式:

单例模式可以确保系统中某个类只有一个实例，该类自行实例化并向整个系统提供这个实力的公共访问点，除了该公共访问点不能通过其他途径访问该实例。

优点：1系统中只存在一个共用的实例对象，无需频繁创建和销毁对象，节约了系统资源，提高了系统性能；2可以严格控制客户何时何方法访问单例对象

特点：1单例类只能有一个实例对象 2单例类必须自己创建自己的唯一实例 3单例类必须给所有其他对象提供这一实例。

在计算机系统中，线程池，缓存，日志对象，对话框，打印机，显卡的驱动程序对象通常被设计为单例，这些应用或多或少具备资源管理器的作用。

1.懒汉式单例

public class Singleton {
    private Singleton(){}
    private static Singleton singleton=null;
    //静态工厂方法
    public static  Singleton getInstance(){
        if(singleton==null){
           singleton=new Singleton();
        }
        return singleton;
    }

}

以上懒汉式单例模式线程不安全，为确保线程安全，提供以下三种方法，都是对getInstance进行改造

1.1.加synchronized同步机制（缺点：每次都需要同步，影响性能）

public class Singleton {
    private Singleton(){}
    private static Singleton singleton=null;
    //静态工厂方法
    public static synchronized Singleton getInstance(){
        if(singleton==null){
           singleton=new Singleton();
        }
        return singleton;
    }

}

1.2双重检查锁定：使用两个if做判断，确保了只有第一次调用单例的时候才会做同步，避免了资源的浪费；volatile关键字的作用是禁止指定重排序

public class Singleton {
    private Singleton(){}
    private volatile static  Singleton singleton=null;
    public static  Singleton getInstance(){
        if(singleton==null){
            synchronized(Singleton.class){
                if(singleton==null){
                    singleton=new Singleton();
                }
            }

        }
        return singleton;
    }
}

1.3静态内部类（利用类加载机制保证初始化instance时只有一个线程，同时保证线程安全）

public class Singleton {
    private static class LazyHolder{
        private static final Singleton INSTANCE=new Singleton();
    }
    public Singleton(){}
    public static final Singleton getInstance(){
        return LazyHolder.INSTANCE;
    }
}

2.饿汉式单例（在类初始化时，已经自行实例化，线程安全）

public class Singleton {
    private Singleton(){}
    private static final Singleton singleton=new Singleton();
    public static Singleton getInstance(){
        return singleton;
    }
}

参考文章：https://blog.csdn.net/a745233700/article/details/83618800