JAVA笔记5__构造块、静态块/单例设计模式/继承/final关键字/super关键字

public class Main {
    { //构造块（在构造对象时调用，先于构造方法执行）
        System.out.println("我是构造块！");
    }
    static{ //静态块（在类加载时执行，且只执行一次【在构造块前执行】eg:数据库连接）
        System.out.println("我是静态块！");
    }
    public Main(){
        System.out.println("我是构造方法！");
    }
    public static void main(String[] args) {
        Main m1 = new Main();
        Main m2 = new Main();
    }  
}

/**
 * 单例设计模式：保证一个类仅有一个实例，并提供一个访问它的全局访问点
 * 1.构造方法私有化
 * 2.声明一个本类对象
 * 3.给外部提供一个静态方法获取对象实例
 * 两种实现方式：饿汉式、懒汉式
 * 应用场合：工具类（例数据库）
 */
public class Main {
    public static void main(String[] args) {
        Singleton1 s1 = Singleton1.getInstance();
        s1.print();
        Singleton1 s2 = Singleton1.getInstance(); 
        Singleton1 s3 = Singleton1.getInstance();
        System.out.println(s1==s2); //输出true，s1,s2,s3都指向同一个对象
        
        Singleton2 t1 = Singleton2.getInstance();
        t1.print();
        Singleton2 t2 = Singleton2.getInstance();
        System.out.println(t1==t2); //输出true，t1,t2指向同一个对象
    }
}

/**
 * 把该类设计成单例设计模式
 * 饿汉式
 */
class Singleton1{
    private static Singleton1 s = new Singleton1(); //饿汉，先new一个对象
    private Singleton1(){}
    public void print(){
        System.out.println("饿汉式单例设计模式！");
    }
    public static Singleton1 getInstance(){
        return s;
    }
}

/**
 * 把该类设计成单例设计模式
 * 懒汉式【在多线程访问时会有线程安全问题】
 */
class Singleton2{
    private static Singleton2 s = null; //懒汉，先不new，调用时再new
    private Singleton2(){}
    public void print(){
        System.out.println("懒汉式单例设计模式！");
    }
    public static Singleton2 getInstance(){
        if(s==null){
            s = new Singleton2();
        }
        return s;
    }
}

/**
 * 继承
 * 1.Java只能实现单继承，也就是一个类只能有一个直接父类
 * 2.继承只能继承非私有的属性和方法（public,protected,default）
 * 3.构造方法不能被继承
 */
public class Main {
    public static void main(String[] args) {
        HomeDog d2 = new HomeDog("hels"); //父类的构造方法先执行(且只能执行父类的默认构造方法【无参】,除非显式调用)
        d2.desc();
    }  
}

class Dog{
    String name;
    public Dog(){
        System.out.println("A dog born.");
    }
    public Dog(String name){
        System.out.println("A dog:"+name+" is born.");
    }
    public void desc(){
        System.out.println("I‘m a dog.");
    }
}
class HomeDog extends Dog{
    public HomeDog(String name){
        super(name); //表示父类的引用【必须放在第一句】
        System.out.println("A HomeDog born.");
    }
    /**
     * 方法的重写
     * 1.发生方法重写的两个方法返回值、方法名、参数列表必须完全一致（子类重写父类的方法）
     * 2.子类抛出的异常不能超过父类相应方法抛出的异常
     * 3.子类方法的访问级别不能低于父类相应方法的访问级别（例：父protected 子public）
     */
    public void desc(){
        System.out.println("我是重写过后的方法！");
    }
    
}
class WildDog extends Dog{
    public WildDog(){
        System.out.println("A WildDog born.");
    }
}

/**
 * super关键字可以完成的操作：
 * 1.调用父类中的属性
 * 2.调用父类中的方法
 * 3.调用父类中的构造方法
 */
public class Main {
    public static void main(String[] args) {
        BlackDuck d1 = new BlackDuck();
        d1.desc();
    }  
}

class Duck{
    protected String name;
    protected int price = 55;
    
    public void count(){
        System.out.println("Duck price is "+price);
    }
}

class BlackDuck extends Duck{
    public void desc(){
        System.out.println("I‘m a BlackDuck,My price is "+super.name);
        super.count();
    }
}

/**
 * final关键字可以完成的操作：
 * 1.声明一个类（最终类，不能被继承）
 * 2.声明一个方法（这个方法不能再被子类重写）
 * 3.声明一个常量(1.直接赋值  2.在构造方法中赋值)
 */
public class Main {
    public static void main(String[] args) {
        Girl g1 = new Girl(30);
        g1.desc();
    }  
}

final class Girl{
    final String name = "fish7";
    final int age;
    public Girl(int age){
        this.age = age;
    }
    public final void desc(){
        System.out.println("I‘m "+name+", My age is "+age);
    }
}