随堂笔记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();}输出：[e-mail]@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("内部类");     } };