本篇要点:
- 单例设计模式
- 初始化代码块
- final关键字
- 抽象方法
- 模板方法设计模式
- 接口
- 工厂设计模式
- 代理模式
- 内部类
一、单例设计模式
- 所谓单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。
- 饿汉式：
class Singleton{ //1.私有化构造器，使得在类的外部不能够调用此构造器 private Singleton(){} //2.在类的内部创建一个类的实例 private static Singleton intsance = new Singleton(); //3.私有化此对象，通过公共的方法来调用 //4.此公共的方法，只能通过类来调用，因为设置为static的，同时类的实例也必须为static声明的 public static Singleton getInstance(){ return instance; } }
懒汉式：class Singleton{ //1.私有化构造器，使得在类的外部不能够调用此构造器 private Singleton(){} //2.在类的内部创建一个空的类的实例 private static Singleton intsance = null; //3.私有化此对象，通过公共的方法来调用 //4.此公共的方法，只能通过类来调用，因为设置为static的，同时类的实例也必须为static声明的 public static Singleton getInstance(){ if(instance == null){ instance = new Singleton(); } return instance; } }
二、初始化代码块
- 初始化代码块分为：非静态代码块（{...}）和静态代码块（static{...}）;
- 非静态代码块：
1.可以有输出语句； 2.可以对类的属性、类的声明进行初始化操作； 3.可以调用静态的变量或方法； 4.若有多个非静态的代码块，那么按照从上到下的顺序依次执行； 5.每次创建对象的时候都会执行一次，且先于狗扎起执行；
静态代码块：1.可以有输出语句； 2.可以对类的属性、类的声明进行初始化操作； 3.不可以对非静态的属性初始化。即：不可以调用非静态的属性和方法； 4.若有多个静态的代码块，那么按照从上到下的顺序依次执行； 5.静态代码块的执行要先于非静态代码块； 6.静态代码块只执行一次；
三、final关键字
- 在Java中使用类、属性和方法时，可以使用关键字final来修饰，表示“最终”；
- final标记的类不能被继承；
- final标记的方法不能被子类重写；
- final标记的变量（成员变量或局部变量）即称常量。名称大写，且只能被赋值一次；
四、抽象类
- 抽象类不可被实例化；
- 抽象类有构造器（凡是类都有构造器）；
- 抽象方法所在的类一定是抽象类；
- 抽象类中可以没有抽象方法，用abstract class 修饰；
- 抽象方法只保留方法的功能，而具体的执行，交给继承抽象类的子类，由子类重写此抽象方法，如格式：public abstract void eat();
五、模板方法设计模式
- 抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式；
- 解决的问题：
1.当功能内部一部分实现是确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。 2.编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给子类实现，就是一种模板模式。
例子：abstract class Template{ public abstract void code(); public void spendTime(){ long start = System.currentTimeMills(); code(); long end = System.currentTimeMills(); } } class SubTemplate extends Template{ public void code(){ boolean flag = false; for(int i = 2; i <= 10000; i++){ for(int j = 2; j <= Math.sqrt(i); j++){ if(i%j==0){ flag = true; break; } } if(!flag){ System.out.println(i); } flag = false; } } } public class TestTemplate{ public static void main(String[] args){ new SubTemplate().spendTime(); } }
六、接口
- 接口（interface）是抽象方法和常量值的定义的集合；
- 实现接口类：class SubClass implememnts InterfaceA{};
- 一个类可以实现多个接口，接口也可以继承其他接口；
- 接口里面的成员变量默认都是public static final类型的，必须被显示的初始化；
- 接口里面的方法默认都是public abstract 类型的， 隐式声明；
- 接口没有构造方法，不能被实例化；
- 类如果实现了一个接口，那么必须实现接口里面的所有抽象方法，否则类要被定义为抽象类；
- 抽象类与接口比较：
1. 接口只能包含抽象方法，抽象类可以包含普通方法。 2. 接口只能定义静态常量属性，抽象类既可以定义普通属性，也可以定义静态常量属性。 3. 接口不包含构造方法，抽象类里可以包含构造方法。
接口主要用来定义规范，解除耦合关系；
七、工厂设计模式
- 定义一个用于创建对象的接口，让子类决定实例化哪一个类，FactortMethod使一个类的实例化延迟到其子类。
- 适用性：
1.当一个类不知道它所必须创建的对象的类的时候 2.当一个类希望由它的子类来指定它所创建的对象的时候 3.当类将创建的对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候；
举例：public class TestFactoryMethod{ public static void main(String[]args){ IWorkFactory i = new StudentWorkFactory(); i.getWork().doWork(); IWorkFactory i1 = new TeacherWorkFactory(); i1.getWork().doWork(); } } interface Work{ void doWork(); } class StudentWork implements Work{ public void doWork(){ System.out.println("学生写作业"); } } class TeacherWork implements Work{ public void doWork(){ System.out.println(“老师批改作业”); } } interface IWorkFactory{ Work getWork(); } class StudentWorkFactory implements IWorkFactory{ public Work getWork(){ return new StudentWork(); } } class TeacherWorkFactory implements IWorkFactory{ public Work getWork(){ return new TeacherWork(); } }
图示：
八、代理模式
- 为其他对象提供一种代理以控制对这个对象的访问；
- 图解：
- 例子：
//接口的应用，代理模式 public class TestProxy{ pubilic static void main(String[] args){ Object obj = new ProxyObject(); obj.action(); } } interface Object{ void action(); } //代理类 class ProxyObject implements Object{ Object obj; public ProxyObject(){ System.out.println("代理类创建成功"); obj = new ObjectImp1(); } public void action(){ System.out.println("代理类开始执行"); obj.action(); System.out.println("代理类执行结束"); } } //被代理类 public ObjectImp1 implements Object{ public void action(){ System.out.println("被代理类"); System.out.println("具体操作代码"); System.out.println("被代理类完毕"); } }
九、内部类
- 内部类：在一个类的内部声明的类；
- 内部类只能在包含它的类中使用，同时它可以看做是该包含类的一段特殊代码，可以直接使用该包含类的变量和方法；
- 内部类编译后也会形成一个单独的class，但它附属于其包含类，创建内部类的对象时会有一个对外部类对象的引用，所以一般只能在非静态方法里创建内部类对象；
- 举例：
1. 内部类使得程序代码更为紧凑，程序更具模块化。 2. 由于内部类被看作类中一段特殊的代码，其可以直接调用类中的成员，因此在一些复杂的调用关系中，使用内部类可以使成员间调用更加方便。 public class Outer { int outer = 100; //在外部类的方法中创建内部类的对象，并调用其方法 void test() { Inner in = new Inner(); in.dispaly(); } //内部类 public class Inner { void dispaly() { System.out.println("dispaly:outer =" + outer); } } }
匿名内部类就是没有名字的类，是将类和类的方法定义在一个表达式范围里。举例：public class Computer { public void show(GraphicsCard card) { card.dispaly(); } public static void main(String[] args) { Computer computer = new Computer(); //使用内部匿名类 computer.show(new GraphicsCard() { public void dispaly() { System.out.println("AMD显卡"); } }); } }
2241
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
