Day10-枚举和抽象类

总结

我是最棒的！基础不牢，地动山摇！

单例模式（Singleton）

饿汉模式

/**
 * 单例模式(饿汉模式)
 * 优点:获取对象的效率高
 * 缺点：类加载在其对象创建之后，效率低，且一直占用内存空间，当类卸载时才会释放空间
 */
public class Singleton {
	
	//private是为了安全，封装，加上static关键字是为了让get方法能够访问到，final表示终态（不可随意改变）
	private static final Singleton INSTANCE = new Singleton();
	
	//私有化构造方法不让其他人随意创建对象
	private Singleton(){
		
	}
	
	//static修饰使用类直接调用
	public static Singleton getInstance(){
		return INSTANCE;
	}
}

懒汉模式

/**
 * 懒汉模式
 * 优点:需要的时候才去创建对象，节省资源空间
 * 缺点:获取对象需要临时创建，获取对象效率低，线程不安全
 */
public class SingletonLazy {
	//封装，先声明但不实例化
	private static SingletonLazy instance;
	
	//私有化构造方法
	private SingletonLazy(){
		
	}
	
	//在饿汉模式的基础上加了判断，当实例未被创建时才创建
	public SingletonLazy getInstance(){
		if(instance == null){
			instance = new SingletonLazy();
		}
		return instance;
	}
}

如何选择某种模式

一般选用饿汉模式，因为饿汉模式是线程安全的，而且现在的硬件资源很大，不在乎饿汉模式一直占用的那一点空间。后期会学习对两种模式进行优化

代码块

普通代码块

一般配合其他关键字使用，比如if，for…

构造代码块

直接写在类中，没有static修饰，

静态代码块

写在类中，有static修饰，在类加载之前就已经执行，用来做一些初始化操作

public class BlockTest {
	
	static{
		System.out.println("我是静态代码块");
	}
	
	{
		System.out.println("我是构造代码块");
	}
	
	public BlockTest() {
		super();
		System.out.println("我是构造方法");
	}

	public static void main(String[] args) {
		
		{
			System.out.println("我是普通代码块");
		}
		
		new BlockTest();
	}

}

/*
	输出结果：
	
	我是静态代码块
	我是普通代码块
	我是构造代码块
	我是构造方法
*/

在多重继承中，执行流程为

最高父类的static代码块–逐级向下—>当前类的static代码块------>最高父类的构造代码块------->最高父类的构造方法—逐级向下------>当前类的构造代码块------>当前类的构造方法

组合关系

一个类中的成员变量中是另一个类的变量（改变固有思想）

如果子类重写了方法，则会调用子类重写的方法（向上造型）

如果需要调用子类中特有的方法，需要用instanceof判断之后，再使用强制类型转换

作用

1. 可以提高代码的复用和扩展性，及时利用javaGC回收垃圾
2. 可以屏蔽子类差异性

注意事项

1. 必须是继承关系
2. **字段（成员变量）**没有多态
3. 多态主要体现在调用方法的时候的表现

示例代码如下

/**
	手机类
*/
public class Phone {
	//手机中有手机卡
	public Card card;

	public Card getCard() {
		return card;
	}

	public void setCard(Card card) {
		this.card = card;
	}
	
	//显示手机号码的方法
	public void showNum(){
		System.out.println("电话号码是:"+card.getPhoneNUm());
	}
}
/**
	手机卡类
*/
public class Card {
	//手机号
	private String phoneNUm;

	public String getPhoneNUm() {
		return phoneNUm;
	}

	public void setPhoneNUm(String phoneNUm) {
		this.phoneNUm = phoneNUm;
	}
}

枚举（enum）

作用

简化取值比较固定的场景（比如性别，星座，段位…）

每一个字段都表示的是当前枚举类的一个对象

public enum Gender {
	MAN,WOMAN,BOYLADY,LADYBOY;
	
	@Override
	public String toString() {
		if(this == MAN){
			return "男";
		}else if (this == WOMAN) {
			return "女";
		}
		else if (this == Gender.BOYLADY) {
			return "妖人";
		}else {
			return "人妖";
		}
	}
}

抽象类(abstract class)

抽象类就是一个特殊的类，需要用abstract修饰，在class关键字前面，一般作为业务父类，

抽象方法

没有方法体，有abstract关键字修饰的方法，只有抽象类才能装抽象方法

注意事项

子类必须重写抽象类中的抽象方法，或者子类也是抽象类

public abstract class Graph {
	
    //抽象类中的求面积方法，各种图形求面积的方法不同，需要强制重写，定义为抽象方法
	public abstract double getArea();
	
}

public class Circle extends Graph {

    //定义元的半径
	private double r;
	
	public Circle(double r) {
		this.r = r;
	}
	
	public Circle() {
		
	}
	
    //重写父类的抽象方法
	@Override
	public double getArea() {
		return Math.PI * r * r;
	}

}

public class Rectangle extends Graph {

    //矩形的长和宽
	private double width;
	private double height;
	
	public Rectangle(double width, double height) {
		this.width = width;
		this.height = height;
	}

	public Rectangle() {
		
	}

    //重写父类的抽象方法
	@Override
	public double getArea() {
		return width * height;
	}

}