1、昨日复习

1. static 修饰的属性，相较于实例变量，有哪些特别之处(>=3点)
   随着类的加载而加载；早于对象的创建；只要权限允许，可以通过”对象.static属性”的方式进行调用；存在于方法区的静态域
   2. final 可以用来修饰哪些结构，分别表示什么意思

2. 代码实现单例模式的饿汉式

3. 代码实现单例模式的懒汉式 -目前还是线程不安全的。

4. 类的属性赋值的位置有哪些？先后顺序为何？
   默认初始化
   显式初始化、代码块中初始化
   构造器中初始化
   通过”对象.属性” 或”对象.方法”的方式赋值
   拓展：工厂设计模式.pdf
   大话设计模式(带目录完整版).pdf
   尚硅谷_宋红康_Java 之23种设计模式解析.pdf.pdf
   深入浅出设计模式(中文版).pdf

   2、抽象类与抽象方法

   有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。
   abstract关键字的使用：
   1、abstract：抽象的
   2、abstract可以用来修饰的结构：类、方法
   3、abstract修饰类：抽象类
   >此类不能实例化
   >抽象类中一定有构造器，便于子类对象实例化时调用（涉及：子类对象实例化的全过程）
   >开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作
   4、abstract修饰方法：抽象方法
   >抽象方法只有方法的声明，没有方法的实现，以分号结束；
   比如：public abstract void talk();
   >包含抽象方法的类，一定是一个抽象类，反之，抽象类中可以没有抽象的方法。
   >抽象类的子类必须重写父类的抽象方法，并提供方法体。若没有重写父类全部的抽象方法，子类也必 为抽象类。

abstract使用上的注意点：
1、abstract不能用来修饰：属性、构造器等结构
2、abstract不能用来修饰私有方法、静态方法、final的方法、final的类

抽象类的匿名子类

3、多态的应用：模板方法设计模式(TemplateMethod)（了解）

当功能内部一部分实现是确定的，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。

4、接 口（interface）

有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。
接口的使用
1、接口使用interface来定义
2、Java中，接口和类是并列的两个结构
3、如何定义接口，定义接口中的成员。
3.1 JDK7及以前：只能定义全局常量和抽象方法，但是书写时可以省略不写。
>全局常量：public static final的
>抽象方法：public abstract的

3.2 JDK8：除了可以定义全局常量和抽象方法之外，还可以定义静态方法、默认方法（default）
接口的成员(字段 + 方法)默认都是 public 的，并且不允许定义为 private 或者 protected。

4、接口中是不能定义构造器的！意味着接口不能实例化
5、Java开发中，接口都通过让类去实现（implements）的方式来使用。如果实现类覆盖了接口中所有的抽象方法，则此实现类就可以实例化；如果实现类没有覆盖接口中所有的抽象方法，则此实现类任然为一个抽象类。

6、Java类可以实现多个接口——弥补了java单继承性的局限性。
定义Java类的语法格式:先写extends，后写implements
7、接口与接口之间是可以多继承
8、接口的具体使用：体现多态性
9、接口，实际上可以看做是一种规范
面试题：抽象类和接口有哪些异同？

1、创建了接口的非匿名实现类的非匿名对象
2、创建了接口的非匿名实现累的匿名对象
3、创建了接口的匿名实现类的非匿名对象
4、创建了接口的匿名实现类的匿名对象

5、接口的应用：代理模式(Proxy)

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

package com.atguigu.java3;
/*
接口的应用
 */
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();
    }
}

package com.atguigu.java3;
public class StaticProxyTest {
    public static void main(String[] args) {
        Star s = new Proxy(new RealStar());
        s.confer();
        s.signContract();
        s.bookTicket();
        s.sing();
        s.collectMoney();
    }
}
interface Star {
    void confer();// 面谈
    void signContract();// 签合同
    void bookTicket();// 订票
    void sing();// 唱歌
    void collectMoney();// 收钱
}
class RealStar implements Star {
    public void confer() {
    }
    public void signContract() {
    }
    public void bookTicket() {
    }
    public void sing() {
        System.out.println("明星：歌唱~~~");
    }
    public void collectMoney() {
    }
}
class Proxy implements Star {
    private Star real;
    public Proxy(Star real) {
        this.real = real;
    }
    public void confer() {
        System.out.println("经纪人面谈");
    }
    public void signContract() {
        System.out.println("经纪人签合同");
    }
    public void bookTicket() {
        System.out.println("经纪人订票");
    }
    public void sing() {
        real.sing();
    }
    public void collectMoney() {
        System.out.println("经纪人收钱");
    }
}

拓展：工厂设计模式.pdf
面试题

interface A {
    int x = 0;
}
class B {
    int x = 1;
}
class C extends B implements A {
    public void pX() {
        System.out.println(x);
    }
    public static void main(String[] args) {
        new C().pX();必须指定x是接口的还是父类的
    }
}

6、Java 8中关于接口的改进

Java 8中，你可以为接口添加静态方法和默认方法。从技术角度来说，这是完全合法的，只是它看起来违反了接口作为一个抽象定义的理念。
1、接口中定义的静态方法，只能通过接口来调用
2、通过实现类的对象，可以调用接口中的默认的方法
3、如果实现类重写了接口中的默认的方法，调用时，任然调用的是重写的方法
4、如果子类或实现类继承的父类和实现的接口中声明了同名同参的方法，那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参的方法。——类优先原则；该原则只能用于方法，如果是属性同名，那么，就必须具体的指定是父类的还是接口的。
5、如果实现类实现了多个接口，而多个接口定义了同名同参数的默认方法，在实现类没有重写此方法的情况下，报错——接口冲突；这就需要我们在实现类中重写此方法。
6、如何在子类或实现类中调用父类，接口中被重写的方法
CompareA.super.method();

7、类的成员之五：内部类（使用频率低）

1、在Java中，允许一个类B的定义位于另一个类A的内部，前者称为内部类，后者称为外部类。
2、内部类的分类：成员内部类（静态的和非静态的） VS 局部内部类（方法内、代码块内、构造器内）
3、成员内部类：
一方面，作为外部类的成员：
>调用外部类的结构，外部类.this.外部方法();
>可以给static修饰
>可以被4种不同的权限修饰符

另一方面，作为一个类：
>类内可以定义属性、方法、构造器等
>可以被final修饰，表示此类不能被继承。言外之意，不使用final
>可以被abstract修饰

4、关注如下3个问题
4.1 如何实例化成员内部类
静态的成员内部类：外部类.内部类 对象 = new 外部类.内部类()；
非静态的成员内部类：外部类 对象1 = new 外部类();
外部类.内部类 对象 = 对象1.new 内部类();或者：
外部类.内部类 对象 = new 外部类().new 内部类();
以上是外部类的外面的方法调用成员内部类

外部类的方法（非静态）调用内部类（不管是不是静态）的方式：直接创建内部类的对象再调用
非静态内部类调用同为内部类（不管是不是静态）的方法：同上。
静态内部类调用同为内部类（静态）的方法：同上
静态内部类调用同为内部类（非静态）的方法：外部类.内部类 对象 = new 外部类().new 内部类();

4.2 如何在成员内部类中区分调用外部类的结构

public void display(String name){
    sout(name);//方法的形参
    sout(this.name);//内部类的属性
    sout(Person.this.name)//外部类Person的属性
}

4.3 开发中局部内部类的使用

public Comparable getComparable(){
    //方式一
    class Mycomparable implements Comparable{
        public int comparaTo(Object o){
            return 0;
        }
    }
    //方式二
    return new Comparable(){
        public int comparaTo(Object o){
            return 0;
        }
    }
}