【JAVA DAY8-代码块、单例模式、Static、内部类、抽象方法、枚举】

代码块

非静态方法可以访问所有的成员、就是说可以访问静态变量以及静态方法

静态方法

静态方法、静态变量：通过类名.方法/变量名访问

代码块

1. 普通代码块

   普通代码块在类被创建的时候就会执行，创建多少个对象就执行多少次，如果只是使用类的静态成员时不会执行。

2. 静态代码块

   静态代码块，在类被创建的时候执行，只会执行一次。

3. 类什么时候被创建？

​ 当你new一个对象时、当你创建子类对象实例父类也会被加载、使用类的静态成员时

静态代码块和静态属性初始化都存在时

1. 静态属性初始化是指，你定义了一个static变量然后给他赋值，赋值赋的是一个静态的有返回值的方法
2. 当new一个对象时，系统会看谁在前，谁在后，顺序调用
3. 

单例模式

上图中GirlFriend是类名，getInstance是一个返回值为GirlFriend的方法，其返回值是一个对象，所以图中的意思就是

用instance来接受返回的对象，所以类型是GirlFriend。

饿汉机制：

1. 在类中声明一个私有构造方法

2. 在类中声明私有的对象，对象的属性什么的都是在类里写（即，传给构造器构造对象的值是在类里面写好的）

3. 然后声明一个公开的方法，返回值是一个类的对象，在外部你就只能调用该类的一个对象，仅仅一个而且属性是在类中被设置好的。

4. 即使在外部你调用多少次方法都是返回同一个对象

饱汉机制

不直接声明对象，而是在外部调用该方法时判断是否需要，如果确实没有该对象，那么就会生成cat

抽象方法

抽象方法：没有方法体的方法，用abstract修饰，声明抽象方法的前提是，方法所属的类是抽象类

如果一个类继承了抽象类，那么它必须重写所有的父类的抽象方法，除非它自己也是抽象类

abstract注意点：

1. abstract不能和finally同时存在，因为abstract需要子类去实现抽象方法
2. abstract不能与static同时使用，因为子类没法重写static方法
3. abstract不能是私有的方法，因为子类没法重写

接口可以看成一种必须实现接口方法中的类
如果一个类实现了接口，那么你必须实现接口中的类，该类可以使用接口中的所有成员（前提有权限）

快速重写快捷键

Ctrl + I: 实现接口方法
Ctrl + O: 重写父类方法

接口的应用

1. 接口在创建的时候需要选择创建接口方法，或者在类中使用关键字interface 名称{}
2. 一个类想要实现接口，那么必须使用关键字implements，且必须实现方法接口中的抽象方法。
3. 在接口中，声明的一般方法是抽象方法，即没有方法体
4. JDK8及以后，可以在接口中使用普通方法，但是需要加关键字default，所有实现接口的类对象都可以调用。

package jiekouapp;

public interface Fnterface {
    public void say();
    default public void hello(){
        System.out.println("我是接口中的方法。");
    }
}

package jiekouapp;

import jdk.jfr.Frequency;

public class opp1 {
    public static void main(String[] args) {
        cat cat = new cat("猫猫");
        cat.say();
        new dog().say();
        cat.hello();
    }
}
class dog implements Fnterface{
    @Override
    public void say(){
        System.out.println("我是小狗，你好。");
    }
}
class cat implements Fnterface {
    //快捷键ctrl+i重写接口
    String name;

    public cat(String name) {
        this.name = name;
    }

    @Override
    public void say() {
        System.out.println("你好我是："+name);
    }
}

你好我是：猫猫
我是小狗，你好。
我是接口中的方法。

内部类

定义：

局部内部类 一图搞定

内部类细节

• 内部类一般都是写在类的方法里面的
  

匿名内部类

系统会自动创建一个类名，但是这个类名你是看不到的，且会继承或者实现运行类型，运行类型是接口，则class的类型也是接口，如果是一个类，那么这个类是它的父类，同时它会自动迅速生成一个该类的对象，你使用的时候只需要用个变量接收它的地址即可，但是接受的类型一定要是匿名内部类的父类或者同类。

成员内部类

• 直接写在类中，而不用写在方法内，不像局部内部类要写在方法里
• 可以访问外部类的所有成员包括私有的。
• 这个类，本质上是个成员，因此你可以给它加修饰符。

外部类如何访问成员内部类

Static 一图搞定

• `静态属性可以被直接访问，即类名.静态
• 

final关键字

在Java中，final关键字可以用来修饰类、方法和变量（包括成员变量和局部变量）。
　1.修饰类
　　当用final修饰一个类时，表明这个类不能被继承。也就是说，如果一个类你永远不会让他被继承，就可以用final进行修饰。
　　final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。
2. 修饰变量
　　当用final作用于类的成员变量时，成员变量（注意是类的成员变量，局部变量只需要保证在使用之前被初始化赋值即可）必须在定义时或者构造器中进行初始化赋值，而且final变量一旦被初始化赋值之后，就不能再被赋值了。
　　且修饰成员变量可以实现底层优化
　　final修饰的变量一般都要大写

自定义枚举

步骤：

1)构造器私有化
2)本类内部创建一组对象
3)对外暴露对象（通过为对象添加public final static修饰符）
4)可以提供get方法，但是不要提供 set方法

2、枚举类

1.使用关键字enum代替class
package Meiju;

public class Meiju1 {
    public static void main(String[] args) {
        Sprint spring = Sprint.SPRING;
        System.out.println(spring);
    }
}
enum Sprint{
    SPRING("春天","温暖");
    String name;
    String qihou;

    Sprint(String name, String qihou) {
        this.name = name;
        this.qihou = qihou;
    }

    @Override
    public String toString() {
        return "Sprint{" +
                "name='" + name + '\'' +
                ", qihou='" + qihou + '\'' +
                '}';
    }
}
2.使用class
package Meiju;

public class Meiju1 {
    public static void main(String[] args) {
        System.out.println(Sprint.SPRING);
    }
}
class Sprint{
    String name;
    String qihou;
    public static Sprint SPRING=new Sprint("春天","温暖");
    Sprint(String name, String qihou) {
        this.name = name;
        this.qihou = qihou;
    }

    @Override
    public String toString() {
        return "Sprint{" +
                "name='" + name + '\'' +
                ", qihou='" + qihou + '\'' +
                '}';
    }
}
3.当使用关键字enum时，即创建枚举类，在类中枚举对象必须放在枚举类的行首，即enum里面的SPRING 必须是在最上面。
4.当有多个枚举对象时，需要用逗号分隔，最后一个别忘了加分号结束。
5.**  枚举类可以直接使用枚举类.枚举对象的方式调用对象。 **

枚举类enum常用方法

package Meiju;

public class Meiju1 {
    public static void main(String[] args) {
        Sprint spring = Sprint.S0;
        //输出对象S0
        System.out.println(spring);
        //输出对象S0的名字
        System.out.println(spring.name());
        //返回当前枚举对象的所有常量
        Sprint pr[]=Sprint.values();
        for (Sprint sprint : pr) {
            System.out.println(sprint);
        }
        //可以发现这是一个引用类型，因此可以用上面的for循环输出
        System.out.println(Sprint.values());
        //其中的字符串必须是已有的对象名，它会根据字符串来匹配这个枚举对象
        Sprint s0 = Sprint.valueOf("S0");
        //我们来输出一下s0看对不对是不是
        System.out.println("s0"+s0);
        //对比两个对象的坐标
        System.out.println(Sprint.S0.compareTo(Sprint.S7));
        //输出对象的名字
        System.out.println(String.valueOf(Sprint.S1));
    }
}
enum Sprint{

    S0("春天","温暖")    ,S1("1","温暖"),   S2("2","温暖"),
    S3("3","温暖"),    S4("4","温暖"),  S5("5","温暖"),
    S6("6","温暖"),    S7("7","温暖");;
    String name;
    String qihou;
    public String s="小王";
    Sprint(String name, String qihou) {
        this.name = name;
        this.qihou = qihou;
    }

    @Override
    public String toString() {
        return "Sprint{" +
                "name='" + name + '\'' +
                ", qihou='" + qihou + '\'' +
                '}';
    }
}

今日有感：感觉今天学的东西很多，但是学的很没有耐心，希望自己能够静下心来，别眼高手低。