第六篇：JAVA之面向对象（下）

来源：互联网发布：mac 查看当前用户名编辑：程序博客网时间：2024/06/05 22:40

本篇要点:

单例设计模式
初始化代码块
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显卡");         }      });   }}

阅读全文

0 0