1.单例模式
*单例设计模式(思想)
*核心思想:在程序的运行当中 该类的对象 不管怎么创建 始终保持 有且只有一个该类的对象
*
*听歌
*听歌(网易 QQ音乐 虾米 )
*不管你是 前台播放 后台播放 使用的都是一个播放器
*单例可以进行 传值
*
*编写单例思路
*1.不让外界创建对象(私有化构造方法)
*2.自己类内部 创建这个对象(让对象只创建一次)
*3.给内外 提供一个获取该对象的方法(相当于提供一个get方法)
*
*
*如何编写单例类
*1.饿汉式(只要该类被加载 就会在方法区静态区中 创建本类对象)
*2.懒汉式(延时加载)
*在类被加载时 不会被创建对象
*只有当 你调用了获取对象方法的时候
*才会创建对象
*/// 饿汉式(只要该类被加载 就会在方法区静态区中 创建本类对象)
class SingleE {
// 声明一个本类的对象
private static SingleE singleE = new SingleE();
// 构造方法私有化
private SingleE() {
}
// 对外提供一个访问的方法(就是为了返回本类的对象)
public static SingleE getInstance() {
return singleE;
}
}
// 懒汉式 (不完整 线程安全问题)
class SingleL {
// 声明一个对象的引用
private static SingleL singleL = null;
private SingleL() {
}
// 获取对象的方法
public static SingleL getInstance() {
// 判断 当这个对象不存在的时候 再创建
if (singleL == null) {
singleL = new SingleL();
}
return singleL;
}2.模板模式
模板设计模式
*
* 大部分东西一样 只需要修改一部分内容
* 简历的抬头
* 简历的名字-----修改
* 简历的内容
*
*来蓝欧学习
*报名缴费
*选择学科(H5 JAVA U3D)
*毕业找工作 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 PQ extends LOStudy{
@Override
public void chooseSubject() {
System.out.println("学H5");
}
}
public static void main(String[] args) {
LOStudy lsk = new LSK();
lsk.study();
}
3.接口
狭义:java中的接口
* 使用interface关键词 来声明
* interface 接口名{
*
* }
* 广义:相当于一个规则 规范 是需要来遵守的
* (蓝欧学生手册)(保密协议)
*
* 接口
* 1.只可以声明抽象方法(是不准确的JDK1.8之前)
* 2.可以声明一个 变量
* 3.接口只能用来实现(不能继承)
* 4.接口中是没有构造方法的
* 5.接口中声明变量默认是public static final
* 默认就是静态常量
* 建议:先写全 写熟了再说 主要看公司规定.
* 6.声明抽象方法时 默认是 public abstract(可省略)
*
* 接口咋运行的?
* 跟类一样 也会被翻译成 .class文件public class Demo03 {
public static void main(String[] args) {
//创建接口 使用多态的形式创建
InterA interA = new InterAImpl();
interA.fun();
System.out.println(InterA.num);
}
}
//声明一个接口
interface InterA{
public static final int num = 10;
public abstract void fun();
}
//接口 使用implements 关键词 实现
//接口的实现类 类名 一般都以Impl结尾
class InterAImpl implements InterA{
//实现接口中 抽象方法
@Override
public void fun() {
System.out.println(num);
System.out.println("我是实现类的 fun方法");
}
}
动物(抽象类)
* 吃 叫
* 训练动物(接口)
* 跳高
* 猫
* 吃猫粮 喵喵
* 加菲猫
* 训练猫
*
* 抽象类 和 接口有什么区别?
* 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 InterE,InterD{
}
class InterFImpl implements InterF{
@Override
public void fun2() {
}
@Override
public void fun1() {
}
}
abstract class Animal{
public abstract void eat();
public abstract void speak() ;
}
class Cat extends Animal{
@Override
public void eat() {
System.out.println("吃猫粮");
}
@Override
public void speak() {
System.out.println("喵喵喵");
}
}
//猫的接口
interface InterCat{
public abstract void jump();
}
class JFCat extends Cat implements InterCat {
//需要实现接口中的方法 先继承后实现
@Override
public void jump() {
System.out.println("我能跳,我能摸到篮板");
}
}
public static void main(String[] args) {
Animal jfAnimal = new JFCat();
jfAnimal.eat();//吃
jfAnimal.speak();//说
//向下转型
JFCat jfCat = (JFCat)jfAnimal;
jfCat.jump();
}4.抽象类
抽象类:描述不清楚就是抽象
* 关键词:abstract
* abstract 可以修饰 类 该类就是 抽象类
* abstract 可以修饰方法 该方法就是 抽象方法
* 当你对这个方法 描述的不是特清楚(不知写啥)
* 就可以直接把该方法 声明成 抽象方法
* 注意:抽象方法没有方法的实现部分
* 注意: 1.有抽象方法的 必须是抽象类
* 2.但是抽象类中 不一定要有抽象方法
* 3.抽象类 不能直接创建对象
* 4.强制子类 重写父类的抽象方法
* 5.创建的时候使用多态的形式进行创建抽象类有啥用?
* 核心:抽象类 不能直接使用 只能使用抽象类的子类
*
* 为什么抽象类 允许构造方法的存在?
* 保证继承的完整性抽象类中有
* 1.可以有变量 常量
* 2.可以有构造方法
* 3.可以有 抽象方法 和 成员方法// 抽象类
abstract class Animal {
final int num = 0;
// 构造方法
public Animal() {
System.out.println("我是Animal 无参的构造方法");
}
// 声明一个抽象方法
public abstract void speak();
public void fun() {
System.out.println("我是fun方法");
}
}
// 抽象类的子类
class Cat extends Animal {
// 子类重写父类的 抽象方法
@Override
public void speak() {
System.out.println("喵喵喵");
}
public static void main(String[] args) {
// 创建一个动物对象
//抽象类如何使用
//使用多态的创建方式
//父类的引用指向子类的对象
Animal aCat = new Cat();
aCat.speak();
}