枚举类型
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("内部类");
}
};