6.面向对象编程(下)

一、关键字：static

当我们编写一个类时，其实就是在描述其对象的属性和行为，而并没有产生实质上 的对象，只有通过new关键字才会产生出对象，这时系统才会分配内存空间给对象， 其方法才可以供外部调用。我们有时候希望无论是否产生了对象或无论产生了多少 对象的情况下，某些特定的数据在内存空间里只有一份，例如所有的中国人都有个 国家名称，每一个中国人都共享这个国家名称，不必在每一个中国人的实例对象中 都单独分配一个用于代表国家名称的变量。

如果想让一个类的所有实例共享数据，就用类变量！

1.类属性、类方法的设计思想

• 类属性作为该类各个对象之间共享的变量。在设计类时,分析哪些属性不因对象的不同而改变，将这些属性设置为类属性。相应的方法设置为类方法。
• 如果方法与调用者无关，则这样的方法通常被声明为类方法，由于不需要创建对象就可以调用类方法，从而简化了方法的调用。
• 使用范围：

• 在Java类中，可用static修饰属性、方法、代码块、内部类

• 被修饰后的成员具备以下特点：

• 随着类的加载而加载
• 优先于对象存在
• 修饰的成员，被所有对象所共享
• 访问权限允许时，可不创建对象，直接被类调用

2.类变量(class Variable)

• 类变量（类属性）由该类的所有实例共享


• 类变量应用举例

class Person { 
  private int id;
  public static int total = 0;
  public Person() {
    total++;
    id = total;
  }
public static void main(String args[]){
  Person Tom=new Person();
  Tom.id=0;
  total=100; // 不用创建对象就可以访问静态成员
  }
}

public class StaticDemo {
public static void main(String args[]) {
  Person.total = 100; // 不用创建对象就可以访问静态成员
  //访问方式：类名.类属性，类名.类方法
  System.out.println(Person.total);
  Person c = new Person();
  System.out.println(c.total); //输出101
  } 
}

3.类变量 vs 实例变量内存解析

4.类方法(class method)

• 没有对象的实例时，可以用类名.方法名()的形式访问由static修饰的类方法。
• 在static方法内部只能访问类的static修饰的属性或方法，不能访问类的非static的结构。
• 因为不需要实例就可以访问static方法，因此static方法内部不能有this。(也 不能有super ? YES!)
• static修饰的方法不能被重写

5.单例 (Singleton)设计模式

• 设计模式==是在大量的实践中总结和理论化之后优选的代码结构、编程风格、 以及解决问题的思考方式。==设计模免去我们自己再思考和摸索。就像是经典 的棋谱，不同的棋局，我们用不同的棋谱。”套路”
• 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。 如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造器的访问权限设置为private，这样，就不能用new操作符在类的外部产生 类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无 法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象， 静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。

单例(Singleton)设计模式-饿汉式

单例(Singleton)设计模式-懒汉式

懒汉式暂时还存在线 程安全问题，讲到多 线程时，可修复

• 单例模式的优点：
  由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的 产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可 以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方 式来解决。
• 举例 java.lang.Runtime

public class Runtime {
    private static Runtime currentRuntime = new Runtime();

    /**
     * Returns the runtime object associated with the current Java application.
     * Most of the methods of class <code>Runtime</code> are instance
     * methods and must be invoked with respect to the current runtime object.
     *
     * @return  the <code>Runtime</code> object associated with the current
     *          Java application.
     */
    public static Runtime getRuntime() {
        return currentRuntime;
    }

    /** Don't let anyone else instantiate this class */
    private Runtime() {}

• 网站的计数器，一般也是单例模式实现，否则难以同步。
• 应用程序的日志应用，一般都使用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。
• 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。
• 项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置 文件数据，都生成一个对象去读取。
• Application 也是单例的典型应用
• Windows的==Task Manager (任务管理器)==就是很典型的单例模式
• Windows的==Recycle Bin (回收站)==也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。

二、理解main方法的语法

• 由于Java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是 public，又因为Java虚拟机在执行main()方法时不必创建对象，所以该方法必须 是static的，该方法接收一个String类型的数组参数，该数组中保存执行Java命令 时传递给所运行的类的参数。
• 又因为main() 方法是静态的，我们不能直接访问该类中的非静态成员，必须创 建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员，这种情 况，我们在之前的例子中多次碰到。

命令行参数用法举例

public class CommandPara {
  public static void main(String[] args) {
    for (int i = 0; i < args.length; i++) {
      System.out.println("args[" + i + "] = " + args[i]);
    }
  }
}

//运行程序CommandPara.java
java CommandPara “Tom" “Jerry" “Shkstart"

//输出结果：
args[0] = Tom
args[1] = Jerry
args[2] = Shkstart

三、类的成员之四： 代码块

• 代码块(或初始化块)的作用：

• 对Java类或对象进行初始化

• 代码块(或初始化块)的分类：

• 一个类中代码块若有修饰符，则只能被static修饰，称为静态代码块 (static block)，没有使用static修饰的，为非静态代码块。

• static代码块通常用于初始化static的属性

class Person {
  public static int total;
  static {
    total = 100;//为total赋初值
  }
  …… //其它属性或方法声明
}

• 静态代码块：用static 修饰的代码块

1. 可以有输出语句。
2. 可以对类的属性、类的声明进行初始化操作。
3. 不可以对非静态的属性初始化。即：不可以调用非静态的属性和方法。
4. 若有多个静态的代码块，那么按照从上到下的顺序依次执行。
5. 静态代码块的执行要先于非静态代码块。
6. 静态代码块随着类的加载而加载，且只执行一次。

• 非静态代码块：没有static修饰的代码块

7. 可以有输出语句。
8. 可以对类的属性、类的声明进行初始化操作。
9. 除了调用非静态的结构外，还可以调用静态的变量或方法。
10. 若有多个非静态的代码块，那么按照从上到下的顺序依次执行。
11. 每次创建对象的时候，都会执行一次。且先于构造器执行。

静态初始化块举例

class Person {
  public static int total;
  static {
    total = 100;
    System.out.println("in static block!");
  }
}

public class PersonTest {
  public static void main(String[] args) {
    System.out.println("total = " + Person.total);
    System.out.println("total = " + Person.total);
  }
}
//输出：
//in static block
//total=100
//total=100

总结：程序中成员变量赋值的执行顺序

1. 声明成员变量的默认初始化
2. 显式初始化、多个初始化块依次被执行（同级别下按先后顺序执行）
3. 构造器再对成员进行初始化操作
4. 通过”对象.属性”或”对象.方法”的方式，可多次给属性赋值

四、关键字：final

• 在Java中声明类、变量和方法时，可使用关键字final来修饰,表示“最终的”。

• final标记的类不能被继承。提高安全性，提高程序的可读性。

• String类、System类、StringBuffer类

• final标记的方法不能被子类重写。

• 比如：Object类中的getClass()。

• final标记的变量(成员变量或局部变量)即称为常量。名称大写，且只 能被赋值一次。

• final标记的成员变量必须在声明时或在每个构造器中或代码块中显式赋值，然后才能使用。
• final double MY_PI = 3.14;

中国古代，什么人不能有后代，就可以被final声明，称为“太监类”！

五、抽象类与抽象方法

随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一 般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父 类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。

• 用abstract关键字来修饰一个类，这个类叫做抽象类。
• 用abstract来修饰一个方法，该方法叫做抽象方法。

• 抽象方法：只有方法的声明，没有方法的实现。以分号结束：
• 比如：public abstract void talk();

• 含有抽象方法的类必须被声明为抽象类。
• 抽象类不能被实例化。抽象类是用来被继承的，抽象类的子类必须重 写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍 为抽象类。
• 不能用abstract修饰变量、代码块、构造器；
• 不能用abstract修饰私有方法、静态方法、final的方法、final的类。

多态的应用：模板方法设计模式(TemplateMethod)

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模 板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象 类的行为方式。

解决的问题：

• 当功能内部一部分实现是确定的，一部分实现是不确定的。这时可以 把不确定的部分暴露出去，让子类去实现。
• 换句话说，在软件开发中实现一个算法时，整体步骤很固定、通用， 这些步骤已经在父类中写好了。但是某些部分易变，易变部分可以抽 象出来，供不同子类实现。这就是一种模板模式。

模板方法设计模式是编程中经常用得到的模式。各个框架、类库中都有他的 影子，比如常见的有：

• 数据库访问的封装
• Junit单元测试
• JavaWeb的Servlet中关于doGet/doPost方法调用
• Hibernate中模板程序
• Spring中JDBCTemlate、HibernateTemplate等

六、接口(interface)

• 一方面，有时必须从几个类中派生出一个子类，继承它们所有的属性和方 法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。
• 另一方面，有时必须从几个类中抽取出一些共同的行为特征，而它们之间又 没有is-a的关系，仅仅是具有相同的行为特征而已。例如：鼠标、键盘、打 印机、扫描仪、摄像头、充电器、MP3机、手机、数码相机、移动硬盘等都 支持USB连接。
• 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要...则 必须能...”的思想。继承是一个"是不是"的关系，而接口实现则是 "能不能" 的关系。
• 接口的本质是契约，标准，规范，就像我们的法律一样。制定好后大家都要遵守。
• 接口(interface)是抽象方法和常量值定义的集合。
• 接口的特点：

• 用interface来定义。
• 接口中的所有成员变量都默认是由public static final修饰的。
• 接口中的所有抽象方法都默认是由public abstract修饰的。
• 接口中没有构造器。
• 接口采用多继承机制。

• 定义Java类的语法格式：先写extends，后写implements
  ​​​class SubClass extends SuperClass implements InterfaceA{ }​​
• 一个类可以实现多个接口，接口也可以继承其它接口。
• 实现接口的类中必须提供接口中所有方法的具体实现内容，方可实 例化。否则，仍为抽象类。
• 接口的主要用途就是被实现类实现。（面向接口编程）
• 与继承关系类似，接口与实现类之间存在多态性
• 接口和类是并列关系，或者可以理解为一种特殊的类。从本质上讲， 接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义 (JDK7.0及之前)，而没有变量和方法的实现。

1.接口的应用：代理模式(Proxy)

概述： 代理模式是Java开发中使用较多的一种设计模式。代理设计就是为其 他对象提供一种代理以控制对这个对象的访问。

public interface Network {
    public void browse();
}

//被代理类
class RealServer implements Network{

    @Override
    public void browse() {
        System.out.println("真是服务i其上网浏览信息");
    }
}

//代理类
class ProxyServer implements Network{
    private Network network;

    public ProxyServer(Network network) {
        this.network = network;
    }

    public ProxyServer() {

    }

    public void check(){
        System.out.println("检查网络连接");
    }
    public void browse(){
        check();
        network.browse();
    }
}

public class ProxyDemo {
    public static void main(String[] args) {
        Network net = new ProxyServer(new ProxyServer());
        net.browse();
    }
}

• 应用场景：

• 安全代理：屏蔽对真实角色的直接访问。
• 远程代理：通过代理类处理远程方法调用（RMI）
• 延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象 比如你要开发一个大文档查看软件，大文档中有大的图片，有可能一个图片有 100MB，在打开文件时，不可能将所有的图片都显示出来，这样就可以使用代理模式，当需要查看图片时，用proxy来进行大图片的打开。
• 分类

静态代理（静态定义代理类）

动态代理（动态生成代理类）

JDK自带的动态代理，需要反射等知识

2.接口和抽象类之间的对比

3.Java 8中关于接口的改进

Java 8中，你可以为接口添加静态方法和默认方法。从技术角度来说，这是完 全合法的，只是它看起来违反了接口作为一个抽象定义的理念。

静态方法：使用 static 关键字修饰。可以通过接口直接调用静态方法，并执行 其方法体。我们经常在相互一起使用的类中使用静态方法。你可以在标准库中 找到像Collection/Collections或者Path/Paths这样成对的接口和类。

默认方法：默认方法使用 default 关键字修饰。可以通过实现类对象来调用。 我们在已有的接口中提供新方法的同时，还保持了与旧版本代码的兼容性。 比如：java 8 API中对Collection、List、Comparator等接口提供了丰富的默认 方法。

4.接口中的默认方法

• 若一个接口中定义了一个默认方法，而另外一个接口中也定义了一个同名同参数的方法（不管此方法是否是默认方法），在实现类同时实现了这两个接口时，会出现：接口冲突。

• 解决办法：实现类必须覆盖接口中同名同参数的方法，来解决冲突

• 若一个接口中定义了一个默认方法，而父类中也定义了一个同名同参数的非 抽象方法，则不会出现冲突问题。因为此时遵守：类优先原则。接口中具有 相同名称和参数的默认方法会被忽略。

七、类的内部成员之五： 内部类

• 当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类。
• 在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类。
• Inner class一般用在定义它的类或语句块之内，在外部引用它时必须给出完整的名称。
• Inner class的名字不能与包含它的外部类类名相同；
• 分类：

• 成员内部类（static成员内部类和非static成员内部类）
• 局部内部类（不谈修饰符）、匿名内部类

• 成员内部类作为类的成员的角色：

• 和外部类不同，Inner class还可以声明为private或protected；
• 可以调用外部类的结构
• Inner class 可以声明为static的，但此时就不能再使用外层类的非static的成员变量；

• 成员内部类作为类的角色：

• 可以在内部定义属性、方法、构造器等结构
• 可以声明为abstract类 ，因此可以被其它的内部类继承
• 可以声明为final的
• 编译以后生成OuterClass$InnerClass.class字节码文件（也适用于局部内部类）

【注意】

1. 非static的成员内部类中的成员不能声明为static的，只有在外部类或static的成员 内部类中才可声明static成员。
2. 外部类访问成员内部类的成员，需要“内部类.成员”或“内部类对象.成员”的方式
3. 成员内部类可以直接使用外部类的所有成员，包括私有的数据
4. 当想要在外部类的静态成员部分使用内部类时，可以考虑内部类声明为静态的

内部类举例1

class Outer{
    private int s;
    public class Inner{
        public void mb(){
            s=100;
            System.out.println("在内部类Inner中s=" + s);
        }
    }
    public void ma(){
        Inner i = new Inner();
        i.mb();
    }
}

public class InnerTest {
    public static void main(String[] args) {
        Outer2 o = new Outer2();
        o.ma();
    }
}

public class Outer2 {
    private int s =111;
    public class Inner{
        private int s =222;
        public void mb(int s){
            System.out.println(s);//局部变量s
            System.out.println(this.s);//内部类对象的属性s
            System.out.println(Outer2.this.s);//外部类对象属性s
        }
    }

    public static void main(String[] args) {
        Outer2 a = new Outer2();
        Outer2.Inner b = a.new Inner();
        b.mb(333);
    }
}

• 如何声明局部内部类

class 外部类{
  方法(){
    class 局部内部类{
    }
  }
  {
    class 局部内部类{
    }
  }
}

• 如何使用局部内部类

• 只能在声明它的方法或代码块中使用，而且是先声明后使用。除此之外的任何地方 都不能使用该类
• 但是它的对象可以通过外部方法的返回值返回使用，返回值类型只能是局部内部类的父类或父接口类型

• 局部内部类的特点

• 内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但 是前面冠以外部类的类名和$符号，以及数字编号。
• 只能在声明它的方法或代码块中使用，而且是先声明后使用。除此之外的任何地方 都不能使用该类。
• 局部内部类可以使用外部类的成员，包括私有的。
• 局部内部类可以使用外部方法的局部变量，但是必须是final的。由局部内部类和局 部变量的声明周期不同所致。
• 局部内部类和局部变量地位类似，不能使用public,protected,缺省,private
• 局部内部类不能使用static修饰，因此也不能包含静态成员

匿名内部类

• 匿名内部类不能定义任何静态成员、方法和类，只能创建匿名内部类的一 个实例。一个匿名内部类一定是在new的后面，用其隐含实现一个接口或 实现一个类。
• 格式：

new 父类构造器（实参列表）|实现接口(){
  //匿名内部类的类体部分
}

• 匿名内部类的特点

• 匿名内部类必须继承父类或实现接口
• 匿名内部类只能有一个对象
• 匿名内部类对象只能使用多态形式引用

public class Test {
    public Test() {
        Inner s1 = new Inner();
        s1.a = 10;
        System.out.println("s1.a" + s1.a);
        Inner s2 = new Inner();
        s2.a = 20;
        System.out.println("s2.a" + s2.a);
        Test.Inner s3 = new Inner();
        System.out.println(s3.a);
    }

    class Inner {
        public int a =5;
    }

    public static void main(String[] args) {
        Test t = new Test();
        Inner r = t.new Inner();
        System.out.println(r.a);
    }
}

拓展：工厂模式

1.无工厂模式

interface car {
    void run();
}

public class Audi implements car{
    public void run(){
        System.out.println("Audi is running");
    }
}

public class BYD implements car{
    @Override
    public void run() {
        System.out.println("BYD running");
    }
}

public class Client01 {
    public static void main(String[] args) {
        Audi audi = new Audi();
        BYD byd = new BYD();
        audi.run();
        byd.run();
    }
}

2.简单工厂模式

interface Car {
    void run();
}
class Audi implements Car{
    @Override
    public void run() {
        System.out.println("Audi running...");
    }
}
class BYD implements Car {
    @Override
    public void run() {
        System.out.println("BYD running");
    }
}

class CarFactory {
    public static Car getCar(String type) {
        if ("Audi".equals(type)){
            return new Audi();
        }else if ("BYD".equals(type)) {
            return new BYD();
        }else {
            return null;
        }
    }
}

public class Client02 {
    public static void main(String[] args) {
        Car audi = CarFactory.getCar("Audi");
        audi.run();
        Car byd = CarFactory.getCar("BYD");
        byd.run();
    }
}

调用者只要知道他要什么，从哪里拿，如何创建，不需要知道。分工，多出了一 个专门生产 Car 的实现类对象的工厂类。把调用者与创建者分离。

小结：

简单工厂模式也叫静态工厂模式，就是工厂类一般是使用静态方法，通过接收的 参数的不同来返回不同的实例对象。 缺点：对于增加新产品，不修改代码的话，是无法扩展的。违反了开闭原则（对 扩展开放；对修改封闭）。

3.工厂方法模式

为了避免简单工厂模式的缺点，不完全满足 OCP（对扩展开放，对修改关闭）。 工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个（对于一 个项目或者一个独立的模块而言）工厂类，而工厂方法模式有一组实现了相同接 口的工厂类。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模 式里不同的工厂子类来分担。

interface Car {
    void run();
}

class Audi implements Car {

    @Override
    public void run() {
        System.out.println("Audi is running");
    }
}

class BYD implements Car{
    @Override
    public void run() {
        System.out.println("BYD is running");
    }
}

//工厂接口
public interface Factory {
    Car getCar();
}

class AudiFactory implements Factory {
    @Override
    public Audi getCar() {
        return new Audi();
    }
}
class BydFactory implements Factory {
    @Override
    public BYD getCar() {
        return new BYD();
    }
}

public class Client {
    public static void main(String[] args) {
        Car a = new AudiFactory().getCar();
        Car b = new BydFactory().getCar();
        a.run();
        b.run();
    }
}

总结： 简单工厂模式与工厂方法模式真正的避免了代码的改动了？没有。在简单工厂模 式中，新产品的加入要修改工厂角色中的判断语句；而在工厂方法模式中，要么 将判断逻辑留在抽象工厂角色中，要么在客户程序中将具体工厂角色写死（就像 上面的例子一样）。而且产品对象创建条件的改变必然会引起工厂角色的修改。 面对这种情况，Java 的反射机制与配置文件的巧妙结合突破了限制——这在 Spring 中完美的体现了出来。

4.抽象工厂模式

==抽象工厂模式和工厂方法模式的区别就在于需要创建对象的复杂程度上。==而且抽象工厂模式是三个里面最为抽象、最具一般性的。

抽象工厂模式的用意为：给客户端提供一个接口，可以创建多个产品族中的产品对象。

而且使用抽象工厂模式还要满足一下条件：

1. 系统中有多个产品族，而系统一次只可能消费其中一族产品。
2. 同属于同一个产品族的产品以其使用。

看过了前两个模式，对这个模式各个角色之间的协调情况应该心里有个数了，我 就不举具体的例子了