[

](Java%E5%9F%BA%E7%A1%80%E5%AD%A6%E4%B9%A0%EF%BC%88%E4%B8%89%EF%BC%89)

1.类变量（静态变量）和类方法（静态方法）static

  1. 类变量是所有类对象共享的，类变量可以通过类名.类变量和对象名.类变量来访问，但通常使用类名.类变量
    类变量是在类加载时就创建了，所以我们没有创建对象实例时，也可以通过类名来访问类变量
  2. 静态方法类似于静态变量，开发自己的工具类时，通常使用静态方法，方便使用。静态方法中不能使用this 和super。只能访问静态变量和静态方法。
  1. package com.static_;
  3. public class TestStatic {
  4.     public static void main(String[] args) {
  5.         Student curry = new Student("Curry");
  6.         curry.count++;
  7.         Student tom = new Student("Tom");
  8.         tom.count++;
  9.         Student car = new Student("Car");
  10.         car.count++;
  11.         System.out.println(curry.count);  //3
  12.         System.out.println(tom.count);   //3
  13.         System.out.println(car.count);   //3
  14.         System.out.println(Student.count);  //3
  16.     }
  17. }
  19. class  Student{
  20.     private String name;
  21.     public static int count;
  23.     public Student(String name) {
  24.         this.name = name;
  25.     }
  26. }

2.代码块

2.1普通代码块

  • 代码块属于初始化块，属于类中的成员，类似与方法，将逻辑语句封装在方法体中。
  • 把相同的语句，放在一个代码块里，不管调用哪个构造器，创建对象，都会优先调用代码块内容
  • 代码块调用的顺序优先于构造器
  • 当创建一个子类对象，父类的构造器也被调用，所以父类中的代码块也会被调用。
  1. package com.codeblock_;
  3. public class CodeBlock01 {
  4.     public static void main(String[] args) {
  5.         Movie movie = new Movie("蜘蛛侠");
  6.         //结果：
  7. //        电影屏幕打开
  8. //        广告开始
  9. //        电影屏幕打开
  10. //         播放蜘蛛侠
  11.         Movie movie1 = new Movie("唐探3", 20, "陈");
  12.         //结果
  13. //        电影屏幕打开 
  14. //        广告开始
  15. //        电影屏幕打开
  16. //        播放唐探3
  18.     }
  20. }
  21. //把相同的语句，放在一个代码块里，不管调用哪个构造器，创建对象，都会优先调用代码块内容
  22. //代码块调用的顺序优先于构造器
  23. class Movie {
  24.     {
  25.         System.out.println("电影屏幕打开");
  26.         System.out.println("广告开始");
  27.         System.out.println("电影屏幕打开");
  28.     }
  30.     private String name;
  31.     private double price;
  32.     private String director;
  34.     public Movie(String name) {
  35.         this.name = name;
  36.         System.out.println("播放"+ name);
  37.     }
  39.     public Movie(String name, double price) {
  40.         this.name = name;
  41.         this.price = price;
  42.         System.out.println("播放"+ name);
  43.     }
  45.     public Movie(String name, double price, String director) {
  46.         this.name = name;
  47.         this.price = price;
  48.         this.director = director;
  49.         System.out.println("播放"+ name);
  50.     }
  51. }

2.2静态代码块

  • static代码块也叫静态代码块，作用就是对类初始化，而且随着类的加载而执行，并且只会执行一次，如果是普通代码块，每创建一个对象就执行。
  • 调用类的静态成员，静态代码块会被调用。
  • 调用子类的静态成员，父类的静态代码块也会被调用。
  • 使用类的静态成员，普通代码块不会被调用。
  1. package com.codeblock_;
  3. public class CodeBlock02 {
  4.     public static void main(String[] args) {
  6.         AA aa = new AA();
  7.         /*输出：
  8.         BB的静态代码块1被执行
  9.         AA的静态代码块1被执行
  10.          */
  11.         System.out.println(Cat.n1);
  12.         /*输出：
  13.         Animal的静态代码块1被执行
  14.         Cat的静态代码块1被执行
  15.         30
  16.          */
  18.     }
  21. }
  22. class Animal {
  23.     static {
  24.         System.out.println("Animal的静态代码块1被执行");
  25.     }
  26. }
  27. class Cat extends Animal{
  28.     public  static int n1 = 30;
  29.     static {
  30.         System.out.println("Cat的静态代码块1被执行");
  31.     }
  32. }
  33. class BB {
  34.     static {
  35.         System.out.println("BB的静态代码块1被执行");
  36.     }
  38. }
  39. class AA extends BB{
  40.     static {
  41.         System.out.println("AA的静态代码块1被执行");
  42.     }
  43. }

-创建一个对象时，调用的顺序为
1.调用静态代码块和静态属性初始化。（优先级一样，按定义的顺序调用）。
2.调用普通代码块和普通属性初始化。（优先级一样，按定义的顺序调用。）
3. 构造器。

  1. package com.codeblock_;
  3. public class CodeBlock03 {
  4.     public static void main(String[] args) {
  5.         A a = new A();
  6. //        结果：
  7. //        getN1被调用
  8. //        A 的静态代码块被调用
  9. //        A的普通代码块被调用%$
  10. //        getN2被调用
  11.     }
  12. }
  14. class A{
  15.     {
  16.         System.out.println("A的普通代码块被调用");
  17.     }
  18.     private int n2 = getN2();
  19.     private static int n1 = getN1();
  20.     static {
  21.         System.out.println("A 的静态代码块被调用");
  22.     }
  23.     public  static int getN1() {
  24.         System.out.println("getN1被调用");
  25.         return 100;
  26.     }
  27.     public int getN2() {
  28.         System.out.println("getN2被调用");
  29.         return 100;
  30.     }
  31. }

2.3 创建一个对象时调用顺序的总结

父类静态代码和静态属性初始化->子类静态代码和静态属性初始化->父类普通代码块和普通属性初始化->父类构造方法->子类的普通代码块和普通属性初始化->子类的构造方法。

3.final关键字

  • 被final修饰的类不能被其他类继承
  • 被final修饰的方法不能被子类重写，可以被继承
  • 被final修饰的属性不能被修改
  • final修饰的属性可以在定义时、代码块、构造器中赋值。
  • 被static修饰的final属性只能在定义和静态代码块中赋值
  • final和static搭配使用，不会导致类加载
  1. package com.codeblock_;
  3. public class CodeBlock04 {
  4.     public static void main(String[] args) {
  5.         System.out.println(Demo.i); //16
  6.     }
  8. }
  10. class Demo {
  11.     public static final int i = 16;
  12.     static {
  13.         System.out.println("demo被加载");
  14.     }
  15. }

4.abstract

  • 当类的方法没有实现，只有定义时，用abstract修饰该方法，这个方法是抽象方法，同时要用abstract修饰该类，该类为抽象类。
  1. abstract class Animal{
  2.     String name;
  3.     int age;
  4.     abstract public void cry();
  5. }
  • 抽象类不能被实例化
  • 如果一个类继承了抽象类，必须实现抽象类的所有抽象方法，否则也要定义为抽象类。

5.接口

结构

  1. interface InterfaceName{
  2.     //属性
  3.     //方法（抽象方法，默认实现方法，静态方法）
  4.     void function();
  5.     default void function1(){};
  6.     static void function2() {};
  7. }
  • 普通类使用接口必须实现接口中的所有方法
  • 接口不能被实例化
  • 抽象类实现接口可以不实现接口中所有方法
  • 一个类可以实现多个接口
  • 接口中的方法默认为public abstract
  • 接口中的属性默认为public static final
  • 接口和接口之间是继承关系

6.内部类

  • 内部类可以直接访问外部类私有属性
  • 分类
    定义在类局部位置上（比如方法内）
    1 局部内部类（有类名）
    2 匿名内部类（没有类名）
    定义在类的成员位置上
    1 成员内部类 （没用static修饰）
    2 静态内部类 （使用static修饰）

6.1 局部内部类

  • 可以直接访问外部类的所有成员，包含私有的
  • 不可以添加访问修饰符，因为他的地位就是一个局部变量，但可以使用final
  • 作用域：仅仅在定义它的方法或代码块中
  • 访问外部类中的成员：直接访问
  • 外部类在方法中，可以创建内部类对象，然后调用内部类成员
  • 外部其他类，不能访问内部类
  • 如果外部类与局本内部类的成员重名，遵循就近原则，如果想访问外部类成员，使用外部类名.this.成员
  1. package com.innerclass;
  3. public class LocalInnerClass {
  4.     public static void main(String[] args) {
  5.         Outer r = new Outer();
  6.         r.m1();
  7.     }
  9. }
  11. class Outer{
  12.     private int n1 = 100;
  13.     private void m2() {
  14.         System.out.println("m2被调用");
  15.     }
  17.     public void m1() {
  18.         //不可以添加访问修饰符，因为他的地位就是一个局部变量，但可以使用final
  19.         //作用域：仅仅在定义它的方法或代码块中
  20.         //外部类在方法中，可以创建内部类对象，然后调用内部类成员
  21.        final class Inner{
  22.            private  int n1 = 800;
  23.             public void f1(){
  24.                 System.out.println("Inner 的 n1 =" + n1);
  25.                 System.out.println("Outer 的 n1 =" + Outer.this.n1);//可以直接访问外部类的所有成员，包含私有的
  26.                 m2();                     //访问外部类中的成员：直接访问
  27.             }
  28.         }
  29.         new Inner().f1();
  30.     }
  31. }

6.2 匿名内部类

  • 相当于继承了类或实现了接口
  1. package com.innerclass;
  3. public class AnonymousInnerClass {
  4.     public static void main(String[] args) {
  5.         Outer01 outer01 = new Outer01();
  6.         outer01.method();
  8.     }
  9. }
  11. class Outer01 {
  12.     private int n1 = 10;
  14.     public void method() {
  15.         //基于接口的匿名内部类
  16.         //类只使用一次，以后不再使用
  17.         //tiger 的编译类型 A
  18.         //tiger 的运行类型 匿名内部类
  21.        A tiger =  new A() {
  22.             @Override
  23.             public void cry() {
  24.                 System.out.println("老虎叫。。。。");
  25.             }
  26.         };
  27.        Father father = new Father("jack"){
  28.            @Override
  29.            public void test() {
  30.                System.out.println("匿名内部类的test");
  31.            }
  32.        };
  33.        tiger.cry();
  34.        father.test();
  35.     }
  37. }
  39. interface A {
  40.     public void cry();
  41. }
  43. class Father {
  44.     public Father (String name){
  46.     }
  47.     public void test() {}
  48. }

6.3 成员内部类

  • 可以访问外部类的所有成员
  • 可以添加访问修饰符
  1. package com.innerclass;
  3. public class MemberInnerClass {
  4.     public static void main(String[] args) {
  5.         Outer02 outer02 = new Outer02();
  6.         outer02.t1();
  7.         Outer02.Inner02 inner02 = outer02.new Inner02(); //创建内部类对象
  8.         inner02.say();
  10.     }
  11. }
  12. class Outer02 {
  13.     private int n1 = 10;
  14.     public String name = "张三";
  15.     class Inner02 {
  16.         public void say() {
  17.             System.out.println("n1 = " + n1 + " name  =  " + name);
  18.         }
  19.     }
  20.     public void t1() {
  21.         Inner02 inner02 = new Inner02();
  22.         inner02.say();
  23.     }
  24. }

6.4 静态内部类

  • 只能访问外部类的静态成员，不能访问非静态成员。
  • 可以添加访问修饰符
  • 可以直接通过外部类名访问
  1. package com.innerclass;
  3. public class StaticInnerClass {
  4.     public static void main(String[] args) {
  5.         //两种创建内部类的方法
  6.         Outer03.Inner03 inner03 = new Outer03.Inner03();
  7.         inner03.say();
  9.         Outer03.Inner03 inner031 = Outer03.Inner03.getInstance();
  10.         inner031.say();
  12.     }
  13. }
  15. class Outer03 {
  16.     private int n1 = 10;
  17.     private static String name = "jack";
  19.     static class Inner03 {
  20.         //只能访问外部类的静态成员，不能访问非静态成员。
  21.         //可以添加访问修饰符
  22.         public void say() {
  23.             System.out.println(name);
  24.         }
  26.         public static Inner03 getInstance() {
  27.             return new Inner03();
  28.         }
  29.     }
  30. }