随堂笔记7.30：枚举，构建者模式，内部类的详细介绍-------2

枚举类型

public enum Gender {
         MALE,FEMALE;
      }
humanTwo.setGender(Gender.FEMALE);//往对象里添加枚举类型

switch里面的枚举
switch (humanTwo.getGender()) {
    case  FEMALE:
        System.out.println("女");
        break;
    case MALE:
        System.out.println("男");
   break;
}

System.out.println(humanTwo);

直接输出一个对象结果是org.lyw.learn02.HumanTwo@1b6d3586
Object中toString()方法输出 类名+@+对象的哈希值

枚举里的方法

public enum Gender {
    MALE("男"){            //可以重写里面的方法
        @Override
        public String getChinese() {
            return "重写";
        }
    },FEMALE("女");
    private String chinese = "中文";//枚举类型里面定义属性
     Gender(String chinese){        //枚举里面可以写构造方法
         this.chinese = chinese;
    }
    public String getChinese(){//枚举里面可以写方法
        return chinese;
    }
}

单例模式

懒汉式

  //懒汉式
public class HumanTwo {

    private static volatile HumanTwo instance;

    public static synchronized HumanTwo getInstance() {
        if (instance == null) {
            //如果在此时线程被抢占。重新判断instance ==null。这是会被创建两个对象。
            // 解决方法：方法加synchronized关键字，
            // 或者加private static volatile HumanTwo instance;，不能完全保证能不被创建。volatile轻量级的线程锁不是特别安全
            instance = new HumanTwo();
        }
        return instance;
    }

    private HumanTwo() {
    }

}

饿汉式

//饿汉式
public class HumanTwo {
    private static HumanTwo instance;

    static {
        //静态代码块在类被第一次使用时调用
        //类被使用：创建类的对象 new HumanTwo(); 调用类的静态属性或方法         HumanTwo.getInstance();  
        instance = new HumanTwo();
        instance.setUsername("1111");//初始化默认值
        instance.setPassword("sads");
        instance.setGender(Gender.FEMALE);
    }

    public static HumanTwo getInstance() {
        return instance;
    }

    private HumanTwo() {
    }

}

• -

在上面类中没有绝对的单例模式

//通过反射能够在单例模式的类中生成第二个对象。所以说单例模式并非绝对的单例。
    //通过枚举类型可以形成绝对的单例，枚举类型只生成一个对象。

System.out.println(HumanTwo.getInstance());
try {
       Constructor<HumanTwo> constructor = HumanTwo.class.getDeclaredConstructor();
       constructor.setAccessible(true);
    HumanTwo humanTwo = constructor.newInstance();
    System.out.println(humanTwo);
} catch (Exception e) {
    e.printStackTrace();
}

输出：
org.lyw.learn02.HumanTwo@1b6d3586
org.lyw.learn02.HumanTwo@4554617c

绝对的单例模式用枚举实现

//通过枚举生成单例
public enum HumanTwo {
    instance;
    static {
        instance.setUsername("1111");//初始化默认值
        instance.setPassword("sads");
        instance.setGender(Gender.FEMALE);
    }
    public static HumanTwo getInstance() {
        return instance;
    }
    private HumanTwo() {
    }
}

静态内部类 构建者模式

构建者模式

package org.lyw.learn02;
import org.lyw.learn01.Gender;
/*
 * 静态内部类，构建者模式
 */
 class User {
    private String name;
    private String password;
    private int age;
    private Gender gender;
    private String email;

      private User(String name, String password, int age, Gender gender, String email) {
        this.name = name;
        this.password = password;
        this.age = age; 
        this.gender = gender;
        this.email = email;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Gender getGender() {
        return gender;
    }
    public void setGender(Gender gender) {
        this.gender = gender;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }


    //使用内部类和使用一般的类相同，
    //静态内部类可以使用外部类所有的静态属性和方法，所有的构造方法
    public static class Builder{
        private String name;
        private String password;
        private int age;
        private Gender gender;
        private String email;

        public Builder(String name, String password) {
            this.name = name;
            this.password = password;
        }

        public Builder setAge(int age) {
            this.age = age;
            return  this;
        }

        public Builder setGender(Gender gender) {
            this.gender = gender;
            return  this;
        }

        public Builder setEmail(String email) {
            this.email = email;
            return  this;
        }
        public User build(){
            return new User(name,password,age,gender,email);
        }
    }
}

构建者模式的使用

public class Test {
    public static void main(String[] args) {

User hsd = new User.Builder("hsd", "122").setAge(12).build();
System.out.println(hsd.getAge());
System.out.println(hsd.getEmail());
}
}

非静态内部类

package org.lyw.learn02;

public class Outer {
    private int a = 30;
    //创建对象时 可以把 outer.new Inner();简化为 outer.getInner();
     public  Inner getInner(){
        return  new Inner();
    }

    //非静态内部类
    //创建内部类对象时一定要先又一个外部类对象
    // 可以访问外部类中所有的属性和方法
    //在非静态内部类中，this为内部当前对象，外部类中，this为外部类的当前对象
    //$ 外部类和内部类的分隔符 Outer$Inner

    public class Inner{
        private int a = 20;
        public void   print(){
             System.out.println(Outer.this.a);
           }
        public void update(){
            Outer.this.a = 100;
           }
    }
}

//当outer创建inner对象的时候是同一个。此时两个内部类对象操作的是同一个外部类对象
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
Outer.Inner inner1=  outer.getInner();
inner.print();
inner.update();
inner.print(); 
inner1.print();

//两个outer创建不同inner对象，操作不同的outer对象
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
Outer outer1 = new Outer();
Outer.Inner inner1=  outer1.getInner();
inner.print();
inner.update();
inner.print();
inner1.print();

匿名内部类

Outer outer = new Outer(){};//匿名内部类
System.out.println(outer);
输出
org.lyw.learn02.Test$1@1b6d3586
//匿名内部类
  //只能创建一个对象
 //在匿名内部类中新定义的方法和属性不可以在外部使用
 //此内部类在静态方法里是静态内部类
 //在非静态方法里为非静态内部类。
 Outer outer = new Outer(){
     @Override
     public void print() {
//         Test test = Test.this;(错误)//不可以在静态中使用非静态的当前对象，可以在非静态中使用该句。
         System.out.println("内部类");
     }
 };