6.面向对象高级部分

一、static

• 静态变量

语法：

static int i;

1. 当需要某个类共享一个变量的时候就可以用静态变量
2. 静态变量随着类加载就初始化了

• 静态方法
  语法：

public static void m1(){}

1. 当方法不和任何对象相关时，可以将方法涉及成静态方法提高开发效率。
2. 静态方法可以直接类名调用，也可以通过对象名调用。
3. 静态方法只能访问静态变量和静态方法。
4. 普通方法静态和动态都可以访问。

二、代码块
代码块属于类的成员，类似于方法，在类加载的时候进行初始化。
语法：

[static] {
代码
}

代码块分为两种，静态和非静态。
静态代码块随着类加载执行，只会执行一次。
类在什么时候会被加载：

1. 创建对象实例new的时候
2. 创建子类对象实例的时候，父类也会被加载
3. 使用类的静态成员时

普通代码块只会在创建对象的时候调用，创建一次，调用一次。

三、final关键字
final可以修饰类、属性、方法、局部变量，在不希望类被继承时，或者方法不想被重写、属性值不被修改时可以使用final关键字修饰。

四、抽象类

1. 当用abstract修饰类/方法的时候，这个类就叫抽象类/方法
2. 抽象类的价值是设计好好后，让子类继承实现抽象类
3. 抽象类不能被实例化
4. 一旦类包含了abstract抽象方法，这个类就必须声明为抽象类，
5. abstract只能修饰类和方法
6. 抽象方法不能有方法体。
7. 类继承了抽象类，就必须实现它的所有抽象方法。除非它也是抽象类
8. 抽象类不能用final， private、static修饰

抽象类-模板设计模式：

  public class AA extends Template {
    // 计算任务
    // 1+....+ 800000
    @Override
    public void job() { // 实现 Template 的抽象方法 job
      long num = 0;
      for (long i = 1; i <= 800000; i++) {
        num += i;
      }
    }

    public void job2() { // //得到开始的时间
      long start = System.currentTimeMillis();
      long num = 0;
      for (long i = 1; i <= 200000; i++) {
        num += i;
      } // 得的结束的时间
      long end = System.currentTimeMillis();
      System.out.println("AA 执行时间 " + (end - start));
    }
  }

  public class BB extends Template {
    @Override
    public void job() { // 这里也去，重写了 Template 的 job 方法
      long num = 0;
      for (long i = 1; i <= 80000; i++) {
        num *= i;
      }
    }
  }

  public class TestTemplate {
    public static void main(String[] args) {
      AA aa = new AA();
      aa.calculateTime(); // 这里还是需要有良好的 OOP 基础，对多态
      BB bb = new BB();
      bb.calculateTime();
    }
  }

五、接口
interface 修饰类名
语法：

public interface UsbInterface { 
    public void start();
    public void stop(); 
}

1. 接口是更像抽象类的抽象类，抽象类可以有普通方法能拥有方法体，接口所有的方法都是抽象方法不能有方法体。
2. jdk8.0后接口可以有静态方法和默认方法。
3. 接口不能被实例化
4. 接口中所有的方法是public方法，可以不用abstract修饰
5. 普通类实现接口必须将该接口的所有方法全部实现
6. 抽象类实现接口可以不用实现接口里的方法
7. 类可以实现多个接口，解决了java只能单继承的问题
8. 接口不能继承其他类，但是可以继承多个其他接口
9. 接口修饰符只能是public和默认

六、内部类
一个类完整的嵌套另一个类就称为内部类
内部类的分类：
定义在外部类局部位置上（如方法内）：

1. 局部内部类（有类名）
2. 匿名内部类 （没有类名）

定义在外部类的成员位置上：

3. 成员内部类（没有static）
4. 静态内部类 （有static）

• 局部内部类：

1. 可以直接访问外部类的所有成员，包含私有的
2. 不能添加访问修饰符， 因为他的地位就是一个局部变量
3. 作用域：仅仅在定义它的方法或者代码块内
4. 局部内部类访问外部成员直接访问即可，外部访问局部成员需要实例化再访问。
5. 外部其他类不能访问。
6. 与外部内的成员变量重名使用就近原则。想调用外部成员变量使用：外部类名.this.成员

• 匿名内部类：

匿名类可以使你的代码更加简洁 (JDK8之后Lambda更简洁)。
你可以定义一个类的同时对其进行实例化。
它与局部类很相似，不同的是它没有类名，如果某个局部类你只需要使用一次，就可以使用匿名类代替局部类。
匿名类是表达式，而非常规的类

• 匿名类的使用场景：

一个局部类只需要使用一次的时候
由于匿名类没有类名，那么除了定义它的地方，其他地方无法调用，所以匿名类也可以叫匿名内部类

演示：

public class HelloWorldAnonymousClasses {

    interface HelloWorld {
        public void greet();
        public void greetSomeone(String someone);
    }

    public void sayHello() {

        /**
         * 1、局部类:EnglishGreeting实现了HelloWorld接口
         */
        class EnglishGreeting implements HelloWorld {
            String name = "无参";
            @Override
            public void greet() {
                greetSomeone(name);
            }
            @Override
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("局部类：" + name);
            }
        }
        // 创建局部类EnglishGreeting的实例化对象，使用接口类型接收
        HelloWorld englishGreeting = new EnglishGreeting();
        // 局部类：无参方法
        englishGreeting.greet();
        // 局部类：带参方法
        englishGreeting.greetSomeone("带参");


        /**
         * 2、匿名类实现HelloWorld接口并创建了实例化对象：frenchGreeting
         */
        HelloWorld frenchGreeting = new HelloWorld() {
            String name = "无参";
            @Override
            public void greet() {
                greetSomeone(name);
            }
            @Override
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("匿名类：" + name);
            }
        };

        // 匿名类：无参方法
        frenchGreeting.greet();
        // 匿名类：带参方法
        frenchGreeting.greetSomeone("带参");
    }

    public static void main(String... args) {
        HelloWorldAnonymousClasses myApp = new HelloWorldAnonymousClasses();
        myApp.sayHello();
    }

输出：

局部类：无参
局部类：带参
匿名类：无参
匿名类：带参

【分析】
  代码里局部类和匿名类实现的功能是一样的，内部的方法实现的代码是也一样的，区别只在实现HelloWorld接口的地方

• 局部类的格式是：

1. 创建局部类并且实现接口：class EnglishGreeting implements HelloWorld {...}
2. 创建局部类的实例化对象并用接口类型接收：HelloWorld englishGreeting = new EnglishGreeting();
3. 调用实例化对象的方法

• 匿名类的格式是：

1. 创建匿名类实现接口同时对其进行实例化：HelloWorld frenchGreeting = new HelloWorld() {...}
2. 调用实例化对象的方法

• 【区别】

1. 局部类EnglishGreeting实现HelloWorld接口，有自己的类名：EnglishGreeting，定义完成后需要再对其实例化对象：englishGreeting才能可以使用方法
2. 匿名类在定义时就已经实例化成对象：frenchGreeting，定义完了就可以直接使用方法
3. 匿名类是一个表达式，因此在定义的最后用分号结束

引用： Java 匿名类

• 成员内部类：
  成员内部类是定义在外部类的成员位置，没有static修饰符

1. 可以直接访问外部类所有成员
2. 可以添加修饰符，因为他的地位是一个成员

class OuterClass {
    class InnerClass {
        
    }
}

成员内部类不止可以在外部类中使用，在其他类中也可以使用。在其他类中创建内部类对象语句非常特殊，语法如下：

外部类 outer = new 外部类();
外部类.内部类 inner = outer.new 内部类();

• 静态成员内部类
  静态成员内部类就是成员内部类加上static修饰符

class OuterClass {
     static class InnerClass {
        
    }
}

因为是静态static，所以可以直接通过类名访问

Outer.Inner inner = new Outer.Inner();
inner.say();