JavaClass Note

目录

#10.1 类变量和类方法

##类变量快速入门

 ##类方法

​编辑 #10.2 理解 main 方法语法

##深入理解 main 方法

##代码块介绍以及使用注意事项和细节讨论 

##重难点：创建实例时加载的顺序

#10.4单例模式

 #10.5 final关键字

#10.6 抽象类

#10.8接口

#10.9内部类

 ##重点：匿名内部类的使用：

---

@[TOC]

#10.1 类变量和类方法

##类变量快速入门

什么是类变量？

说明：类变量是随着类的加载而创建，所以即使没有创建对象实例也可以访问

 

 ##类方法

 

 类方法使用注意事项和细节讨论 

 #10.2 理解 main 方法语法

##深入理解 main 方法

特别提醒：

1) 在 main()方法中，我们可以直接调用 main 方法所在类的静态方法或静态属性。

2) 但是，不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员

##代码块介绍以及使用注意事项和细节讨论 

基本介绍

1）相当于另外一种形式的构造器（对构造器的补充机制），可以i做初始化操作

2）如果多个构造器中都有重复的语句，可以抽取到初始化块中，提高代码的重用性

##重难点：创建实例时加载的顺序

#10.4单例模式

##饿汉式

/*
饿汉式
步骤：
//1. 将构造器私有化
//2. 在类的内部直接创建对象(该对象是 static)
//3. 提供一个公共的 static 方法，返回 gf 对象
 */

public class SingletonMode {
  public static void main(String[] args) {
Girlfriend instance =Girlfriend.getInstance();
    System.out.println(instance);
  }
}

class Girlfriend{
  private static String name;

  private static Girlfriend gf=new Girlfriend("小红");

  private Girlfriend(String name) {
    this.name=name;
}

public static Girlfriend getInstance(){
    return gf;
}

  @Override
  public String toString() {
    return "GirlFriend{" + "name='" + name + '\'' + '}';
  }
}

##饱汉式

/*  懒汉式
//步驟
//1.仍然構造器私有化
//2.定義一個 static 靜態屬性對象
//3.提供一個 public 的 static 方法，可以返回一個 Cat 對象
//4.懶漢式，只有當用戶使用 getInstance 時，才返回 cat 對象, 後面再次調用時，會返回上次創建的 cat 對象,從而保證了單例
 */

public class SingletonMode2 {
  public static void main(String[] args) {
    System.out.println(Cat.n);
    Cat instance=Cat.getinstance();
    System.out.println(instance);
    Cat instance2=Cat.getinstance();
    System.out.println(instance2);
  }
}

class Cat{
  public static int n=100;
  private String name;
  private static Cat cat;

  private Cat(String name){
    System.out.println("构造器被调用...");
    this.name=name;
  }


  public static Cat getinstance(){
    if(cat==null)
      cat=new Cat("小可爱");
    return cat;
  }

  @Override
  public String toString() {
    return "Cat{" +
      "name='" + name + '\'' +
      '}';
  }
}

 #10.5 final关键字

#10.6 抽象类

##细节讨论 

1)   抽象类不能被实例化

2）抽象类不一定要包含abstract方法，也就是说抽象类可以没有abstract方法

3）一旦包含了abstract方法，那这个类必须是抽象类

4）abstract只能修饰类和方法，不能修饰其他的

5）抽象类本质还是类，可以有任意成员，如非抽象方法、构造器、静态属性等

6）抽象方法不能有方法体，即不能实现

7）如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类

8）抽象方法不能使用 private、final 和 static 来修饰，因为这些关键字都是和重写相违背的

#10.8接口

## 注意事项和细节

1）接口不能被实例化

2）接口中所有的方法是public方法，接口中抽象方法，可以不用abstract修饰

3）一个普通类实现接口，就必须将接口中所有方法实现

4）抽象类实现接口，可以不用实现接口的方法

5）一个类同时可以实现多个接口

6）接口中的属性，只能是final的，而且是public static final修饰符。比如：int a=1；实际上是public static final int a=1；（必须初始化）

7）接口中属性的访问形式：接口名.属性

8）接口中不能继承别的类，但可以继承别的多个接口

9）接口的修饰符只能是public和默认，这点和类的是一样的

#10.9内部类

分类：

定义在外部类局部位置上（比如方法内）

局部内部类（有类名）

匿名内部类（没有类名）

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

成员内部类（没有static修饰）

静态内部类（有static修饰）

 ##重点：匿名内部类的使用：

基本语法：、

new 类或接口（参数列表）{

类体

}；

//匿名内部类使用一次就不能再使用了
    A tiger=new A() {//基于接口的匿名内部类
      @Override
      public void cry() {
        System.out.println("老虎叫唤...");
      }
    };
tiger.cry();
    System.out.println(tiger.getClass());//系统分配的类名


    Father dog=new Father("micgo"){//基于类的匿名内部类
      @Override
      public void test() {
        System.out.println("内部类重写了方法");
      }
    };
    dog.test();
    System.out.println(dog.getClass());

    Animal animal = new Animal(){//基于抽象类的匿名内部类
      @Override
      void eat() {
        System.out.println("重写了eat方法");
      }
    };
    animal.eat();
    System.out.println(animal.getClass());
  }

内部类的实践：可以当作实参直接传递

outer.AA(new A() {
      @Override
      public void cry() {
        System.out.println("汪汪...");
      }
    });