Java-06面向对象（下）

七、Java-06面向对象（下）

7.1 static

7.1.1 让一个类的所有实例共享数据

7.1.2 特点

1. 类属性作为该类各个对象之间共享的变量。在设计类时,分析哪 些属性不因对象的不同而改变，将这些属性设置为类属性。相应 的方法设置为类方法。
2. 如果方法与调用者无关，则这样的方法通常被声明为类方法，由 于不需要创建对象就可以调用类方法，从而简化了方法的调用。
3. 随着类的加载而加载，可以通过类. 静态方法进行调用
4. 优先于对象存在
5. 修饰的成员，被所有对象所共享
6. 访问权限允许时，可不创建对象，直接被类调用

7.1.3 注意：

• 在静态的方法内，不能使用this关键字、super关键字

•      关于静态属性和静态方法的使用，大家都从生命周期的角度取理解
  

7.1.3 适用范围

可用static修饰属性、方法、代码块、内部类

7.2 单例模式

7.2.1 饿汉式

class Bank{

    //1.私有化类的构造器
    private Bank(){//不私有化就会构造无限个对象

    }
    //2.内部创建类的对象
    private static Bank instance = new Bank();//必须有static。属性是静态的那么对象也得是静态的
    //3.因为私有化了 不能够在外创建对象。所以提供公共的方法，返回类的对象
    public static Bank getInstance(){
        return instance;
    }
}

7.2.2 懒汉式

class Order{
    //1.私有化类的构造器
    private Order(){

    }
    //2.声明当前类对象，没有初始化
    //4.此对象也必须声明为static的
    private static Order instance = null;
    //3.声明public、static的返回当前类对象的方法
    public static Order getInstance(){
        if(instance == null){
            instance = new Order();
        }
        return instance;
    }
}

7.2.3 单例模式的优点

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

7.3 代码块

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

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

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

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

7.4 final

7.4.1 特点

1. final标记的类不能被继承。提高安全性，提高程序的可读性。
   1. String类、System类、StringBuffer类
2. final标记的方法不能被子类重写。
   1. 比如：Object类中的getClass()。
3. final标记的变量(成员变量或局部变量)即称为常量。名称大写，且只能被赋值一次。

7.5 抽象类和抽象方法

7.5.1 abstract修饰类：抽象类

• ①此类不能实例化

•  ②抽象类中一定有构造器，便于子类实例化时调用（涉及，子类对象实例化的全过程）
  

•  ③开发中，父类既然被抽象不能实例了，但是，都会提供抽象类的子类，让子类对象实例化，完成相关的操作
  

7.5.2 abstract修饰方法：抽象方法

• ①抽象方法只有方法的声明，没有方法体

•  ②包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象给方法的
  

•  ③若子类重写了父类中的所有的抽象方法以后，此子类方可实例化；若子类没有重写父类中的所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰
  

package java01抽象类与抽象方法;

/**
 *  abstract关键字的使用
 *  1.abstract：抽象的
 *  2.abstract可以用来修饰的结构，类、方法
 *
 *
 *  3.abstract修饰类：抽象类
 *      ①此类不能实例化
 *      ②抽象类中一定有构造器，便于子类实例化时调用（涉及，子类对象实例化的全过程）
 *      ③开发中，父类既然被抽象不能实例了，但是，都会提供抽象类的子类，让子类对象实例化，完成相关的操作
 *
 *  4.abstract修饰方法，抽象方法
 *      ①抽象方法只有方法的声明，没有方法体
 *      ②包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象给方法的
 *      ③若子类重写了父类中的所有的抽象方法以后，此子类方可实例化；若子类没有重写父类中的所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰
 *
 */
public class AbstractTest {
    public static void main(String[] args) {
//        一旦Person类被抽象了，就不可实例化了
//        Person p1 = new Person();
//        p1.eat();

    }
}

abstract class Person{
    String name;
    int age;
    public Person(){

    }
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    //抽象方法
    public abstract void eat();
    public void walk(){
        System.out.println("人走路");
    }
}

// abstract class Student extends Person{
//    public Student(String name,int age){
//        super(name, age);
//    }
//}
class Student extends Person{
    public Student(String name,int age){
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("学生多吃有营养的食物");
    }
}

7.5.3 定义

• 用abstract关键字来修饰一个类，这个类叫做抽象类。
• 用abstract来修饰一个方法，该方法叫做抽象方法。
  • 抽象方法：只有方法的声明，没有方法的实现。以分号结束： 比如：public abstract void talk();

7.5.4 特点

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

7.6 接口interface

7.6.1 定义

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要…则 必须能…”的思想。继承是一个"是不是"的关系，而接口实现则是 “能不能” 的关系。

7.6.2 特点

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

7.6.3 格式

先写extends，后写implements

7.6.4 代理模式

package 接口03代理模式;

/**
 * 接口的应用，代理模式
 */
public class NetWorkTest {
    public static void main(String[] args) {
        Server server = new Server();
        ProxyServer proxyServer = new ProxyServer(server);
        proxyServer.browse();
    }
}

interface NetWork{
    public void browse();
}

//被代理类
class Server implements NetWork{

    @Override
    public void browse() {
        System.out.println("真实的服务器访问网络");
    }
}

//代理类
class ProxyServer implements NetWork{

    private NetWork work;
    public ProxyServer(NetWork work){
        this.work = work;
    }
    public void check(){
        System.out.println("联网之前的检查工作");
    }
    @Override
    public void browse() {
        check();
        work.browse();
    }
}

7.7 接口和抽象类的对比

No	区别点	抽象类	接口
1	定义	包含抽象方法的类	主要是抽象方法和全局常量的集合
2	组成	构造方法、抽象方法、普通方法、 常量、变量	常量、抽象方法、(jdk8.0:默认方法、静态方法)
3	使用	子类继承抽象类(extends)	子类实现接口(implements)
4	关系	抽象类可以实现多个接口	接口不能继承抽象类，但允许继承多个接
5	常见设计模式	模板方法	简单工厂、工厂方法、代理模式
6	对象	都通过对象的多态性产生实例化对象	都通过对象的多态性产生实例化对象
7	局限	抽象类有单继承的局限	接口没有此局限
8	实际	作为一个模板	是作为一个标准或是表示一种能力
9	选择	如果抽象类和接口都可以使用的话，优先使用接口，因为避免单继承的局限	如果抽象类和接口都可以使用的话，优先使用接口，因为避免单继承的局限