Java基础总结(三)类与对象(下)

static 关键字

static 关键字修饰的成员就是类成员，前面已经介绍的类成员有类变量、类方法、静态初始化块。static不能修饰构造器，其修饰的类成员属于整个类，不属于单个实例。

当创建对象后，成员变量是存储在堆中的，而static成员变量和类的信息一起存储在方法区, 而不是在堆中。

单例类

如果一个类始终只能创建一个实例，则这个类被称为单例类。在一些特殊场景下，要求不允许自由创建该类的对象，而只允许为该类创建一个对象。为了避免其他类自由创建该类的实例，应该把该类的构造器使用private修饰，从而把该类的所有构造器隐藏起来。一旦把该类的构造器隐藏起来，就需要提供一个public方法作为该类的访问点，用于创建该类的对象，且该方法必须使用static修饰（因为调用该方法之前还不存在对象，因此调用该方法的不可能是对象，只能是类)。

class Singleton {

    // 使用一个类变量来缓存曾经创建的实例
    private static Singleton instance;

    // 对构造器使用private修饰
    private Singleton() {
    }

    // 提供一个静态方法，用于返回Singleton实例
    public static Singleton getInstance() {
        // 如果instace为null,则表明还不曾创建Singleton对象，否则相反，将不会创建新的实例。
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

public class SingletonTest {
    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s1 == s2);
    }
}

final 关键字

• final 修饰变量
  final关键字修饰变量，意为不可改变。final可以修饰成员变量，也可以修饰局部变量。

 public class TestFinal {
    private final int age = 1;
    public void test() {
        //age = 2;编译错误
    }
}

• final 修饰方法
  final关键字修饰的方法不可以被重写。使一个方法不能被重写的意义在于：防止子类在定义新方法时造成的“不经意”重写。

• final 修饰类
  final关键字修饰的类不可以被继承。使一个类不能被继承的意义在于：可以保护类不被继承修改，可以控制滥用继承对系统造成的危害。在JDK中的一些基础类库被定义为final的，例如：String、Math、Integer、Double 等等。

• static final 常量
  static final 修饰的成员变量称为常量，必须声明同时初始化，并且不可被改变。常量建议所有字母大写。

class Foo {
    public static final int NUM = 100;
}
class Goo {
    public static void main(String[] args) {
        Sytem.out.println(Foo.NUM);  
        // 代码编译时，会替换为：System.out.println(100);
    }
}

抽象类

抽象方法和抽象类的规则如下：
- 抽象类必须使用 abstract 修饰符来修饰，抽象方法也必须使用 abstract来修饰，抽象方法不能有方法体。
- 抽象类不能被实例化，即使抽象类里不包含抽象方法，这个抽象类也不能创建实例。
- 含有抽象方法的类只能被定义成抽象类。

public abstract class TestAbstract {
    private String name;
    public void test() {
        System.out.println("");
    }
    public abstract void t();
}
class DoTest extends TestAbstract{

    @Override
    public void t() {
        System.out.println("fs");
    }
}

抽象类作用：抽象类体现的就是一种模板模式的设计，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现。

接口

接口的定义：

[修饰符] interface 接口名 extends 父接口1，父接口2...{
    零到多个常量定义...
    零到多个抽象方法定义...
    零到多个内部类、接口、枚举定义...
    零到多个默认方法或类方法定义...
}

public interface Test {
    public static final int age = 12; //常量定义
    public void run(); //抽象方法
    public static void test() { //类方法
        System.out.println("fsf");
    }
    public default String say() {
        return "";
    }
}

接口的继承
接口支持多继承，子接口扩展某个父接口，将会获得父接口里定义的所有抽象方法、常量。
使用接口
接口主要用来被实现类实现，使用关键字implements

[修饰符] class 类名 extends 父类 implements 接口1,接口2...{
    类体部分
}

内部类

一般情况下，我们把类定义成独立的单元。有些情况下，我们把一个类放在另一个类的内部定义，称为内部类。
内部类的作用：

• 内部类提供了更好的封装。只能让外部类直接访问，不允许同一个包中的其他类直接访问。
• 内部类可以直接访问外部类的私有属性，内部类被当成其外部类的成员，但外部类不能访问内部类的内部属性。
  匿名内部类
  使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口
  
new 父类构造器(实参列表) | 实现接口(){
重写方法
}

  注意两个问题
• 使用的形参为何要为final？

• 匿名内部类初始化的初始化问题

  public class TestNoName {
  public void T() {
      new Found() {
          @Override
          public void go() {
              System.out.println("sdf");
          }
      };
  }
  }
  class Found{
  public void go() {
      System.out.println("我是父类");
  }
  }