一、单例设计模式
核心思想: 在程序运行中,该类的对象无论怎么创建,始终保持有且仅有一个该类的对象
编写单例类:
1. 私有化构造方法
2.自己类内部创建对象 并且 私有化private 静态化static
3.给类外部 提供一个获取该对象的方法
饿汉式单例类:
class Single {
// 声明一个本类对象 私有化 静态化
// 外界无法访问 随着类的加载只加载一次
private static Single single = new Single();
// 私有化构造方法 外界无法创建本类对象
private Single {
}
// 对外提供一个访问本类私有化对象的方法(返回本类的对象)
public static Single getInstance(){
return single;
}
}懒汉式单例类:
class Single {
private static Single single = null;
private Single {
}
public static Single getInstance() {
if(single == null){
single = new Single();
}
return single;
}
}
二、抽象类
抽象: 描述不清的即为抽象
抽象类 关键词 abstract
abstract 修饰类 该类即为抽象类
abstract 修饰方法 该方法则为抽象方法
注意: 抽象方法没有方法的实现部分
注意:
1. 有抽象方法的类 必须定义为抽象类
2.抽象类中不一定有抽象方法
3.抽象类不能直接创建对象
4.强制子类重写父类的抽象方法
5.使用多态形式创建对象
核心: 抽象类不能直接使用 只能使用抽象类的子类
抽象类允许构造方法的存在 是因为抽象类需要借助子类创建对象,为了保证继承的完整性
abstract class Animal {
final int num = 10; // 常量必须初始化赋初值
// 构造方法
public Animal() {
System.out.println("我是Animal 无参的构造方法");
}
// 声明一个抽象方法(没有实现部分)
public abstract void speak();
public void fun() {
System.out.println("我是fun方法");
}
}
注意: abstract 不能与 private final static 共存
abstract抽象类 强制子类去重写抽象方法
private私有化 只能奔雷访问 无法被继承重写
final 修饰抽象方法 则该方法无法被修改 被重写
static 修饰抽象方法 则可使用类名直接调用 抽象方法没有实现部分,不能直接调用
三、模板设计模式
思想: 大部分内容一样 只需要修改一部分内容
abstract class LOStudy {
// 学习方法
public void study() {
System.out.println("报名学计算机");
// 选择学科是需要变化的 声明一个抽象方法
// 调用抽象方法
chooseSubject();
System.out.println("毕业找工作");
}
// 声明抽象方法
public abstract void chooseSubject();
}
class LSK extends LOStudy {
// 重写抽象方法
@Override
public void chooseSubject() {
System.out.println("学Java");
}
}
class LNA extends LOStudy {
@Override
public void chooseSubject() {
System.out.println("学H5");
}
}
计算一段程序的执行时间: System.cuttrntTimeMillis() 方法
long time = System.cuttrntTimeMillis() ;
获取的是 当前时间 到 1970年1月1日 的时间 (格林尼治时间)
long start = System.currentTimeMillis();
// 执行某一个程序
chengXu();
long stop = System.currentTimeMillis();
System.out.println("该循环耗时:" + (stop - start) + "ms");
四、接口
狭义: Java中的接口使用interface关键词来声明
interface 接口名 { }
广义: 看做 一个规则、规范 需要来遵守的
注意:
1.只能声明 抽象方法(JDK 1.8 可以声明静态方法 和 默认方法)
2.可以声明变量 (实际为常量)
3.接口不能被继承 只能用来实现
4.接口没有构造方法 (接口是用的是实现 不用继承)
5.接口中声明的变量 默认是 public static final 修饰
默认就是静态常量
6.声明抽象方法时 默认是 public abstract修饰
接口的运行与类一样 翻译成.class文件被执行
接口的实现类:
接口的实现类 接口使用implements 关键词 实现
// 声明一个接口
interface InterA {
int num = 10;
public abstract void fun();
}
// 接口的实现类
class InterAImpl implements InterA {
// 实现接口的抽象方法
@Override
public void fun() {
System.out.println(num);
}
}
抽象类和接口的区别:
1.使用方法
抽象类是继承,接口是实现
2.成员变量
抽象类可以是常量也可以是变量,接口只能是常量
3.成员方法
抽象类可以使成员方法也可以是抽象方法,接口只能使抽象方法
4.构造方法
抽象类有构造方法 接口中没有构造方法
类与类之间的关系: 只允许单继承
类与接口之间的关系: 实现关系 可以多实现
接口和接口的关系: 可以单继承 也可以多继承
// 类和接口的关系
interface InterB {
public abstract void fun1();
}
interface InterC {
public abstract void fun2();
}
class TestA implements InterB,InterC {
@Override
public void fun2() {
}
@Override
public void fun1() {
}
}
// 接口和接口的关系
interface interD {
public abstract void fun1();
}
interface interE {
public abstract void fun2();
}
interface interF extends interD,interE {
}
class interFImpl implements interF {
@Override
public void fun1() {
}
@Override
public void fun2() {
}
}
一个类即继承父类又是接口的实现类时 先写继承再写实现
class Abc extends AAA implements BBB { }
默认方法 用default关键词修饰
默认方法不需要必须在实现类中重写
调用父类中的默认方法 : 接口名.super.默认方法名