总结
我是最棒的!基础不牢,地动山摇!
单例模式(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判断之后,再使用强制类型转换
作用
- 可以提高代码的复用和扩展性,及时利用javaGC回收垃圾
- 可以屏蔽子类差异性
注意事项
- 必须是继承关系
- **字段(成员变量)**没有多态
- 多态主要体现在调用方法的时候的表现
示例代码如下
/**
手机类
*/
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;
}
}