《Java核心技术》 -- 读书笔记 ② - 类 | 对象 | 接口

对象vs对象变量

“对象” 描述的是一个类的具体实例，他被java虚拟机分配在 "堆" （Heap）中。

“对象变量” 为一个对象的引用（对象变量的值=记载着具体对象的位置/地址），他被分配在 "栈" （Stack） 上。

Date birthday = new Date();

birthday - 即为对象变量，他被分配在 Stack 上，初始化的Date对象被分配在 Heap 中，如图：

方法的隐式参数

在Java中，通常将 this 关键字称为方法的隐式参数。例如

public class Employee{

    private double salary;

    public void raiseSalary(double byPercent){
           double raise = this.salary * byPercent /100;
           this.salary += raise;
    }

}

final 实例域

表示该实例应在其所在类的构造函数中赋值且之后是不可变的。例如定义常量。

static 关键字的用法

1. static + variable ： 定义一个属于类的变量，无论有多少个该类的实例对象，这个static变量的值均一样（指向同一个实例域）。

public class Employee{

    private static int uniqueCode = 12345;

}

所有employee对象的 uniqueCode 都指向同一个实例域。所以他们的值都相等 =1；

2. static + final + variable: 通常用于定义常量：

public class Math {
  ...
  priave static final PI = 3,1415926;
  ...
}

3. 静态方法 - 直接通过 class.function() 的方式调用

4. 工厂方法 - 通过getXXXInstance（）的方式返回对象

5. Main 方法

初始化块

可以分为：

1.静态初始化块

2.对象初始化块

他们的执行顺序是根据定义的先后顺序，依次执行。例如

public class Employee{

      private static int nextId;
      private int id;

      // static init block
      static {
           Radom radom = new Radom();
           nextId = radom.nextInt(10000);
      }

      // object init block
      {
            id = 1;
       }

}

包 （package）

目的： 保证类的唯一性；存放相同功能的一群类。

Jar (java 归档文件包)

使用 zip 格式压缩来组织文件目录以及子目录

-----

派生类调用父类的方法 super.fuc();

注意： supper 是一个关键字而不是对象。

object:所有对象的超类

hashcode() - 该方法默认情况下返回内存地址；String类型是特例他的返回值是由String的字符串值生成的。因此，当s1="OK", s2="OK"时，s1.hashcode() 等于 s2.hashcode()

泛型数组列表 - ArrayList<T>

// 定义1
ArrayList<Employee> employeeList = new ArrayList<Employee>();

// 定义 2
ArrayList<Employee> employeeList = new ArrayList<>();

两种定义均可，第二种为简写形式。

在定义ArrayList是，可以传递“capacity”指定大小，这么做只是分配给数组列表，一次性存储这么多对象的“潜力”，实际上在定义的还没有没有分配空间。

ArrayList.Set(int index, T obj); //设置某位的值-覆盖原值

ArrayList.Add(int index, T obj); //添加值-原来的值后移

使用 @SuppressWarning(“Uncheck”) 来接受类型转换的警告。

pulic class Test{
   private ArrayList findQueryResult(){
      ...
   }

    @SupperssWaring("Uncheck")
     ArrayList<Employee> list = this.findQueryResult();
}

枚举类

枚举类型实际上是一个类、他的常用发放有

valueof - 设置枚举实例的值。 Size s = Emum.valueof(Size.Class, "SMALL");

toString - 返回实例的字符串值

values - 返回全部枚举值的数组

ordinal - 返回枚举常亮的位置

反射

获取Class对象的三种方式：例如：

1. Employee.Class

2. e.getClass()

3. Class.forClass("Employee")

常用方法：

class.getName() 返回类名（完全名称，包括包名）

class.newInstance() 构造对象 ： Employee e1 = Class.forClass("com.xxx.Employee").newInstance();

接口

接口定义了一系列的“行为准则”，类如果要实现（implements）接口，必须要实现接口中的所有方法。

接口中的方法默认为 “public”的，所以不必显示生命为public。

接口中的域（字段），默认为public static final

内部类

使用内部类的三种情况：

1. 访问类中的域以及数据，包括私有的域和数据。

2. 对所属包中的其他类隐藏。

3. 多用匿名方法，视线回调函数。

一、编译器在编译内部类中是，会为其添加一个对于她的外部类的引用引用，我们将它称之为“out”, 例如：

public class TalkingClock{
    private bool beep;
    private int interval;

     public TalkingClock(int interval, bool beep){
           this.interval=interval;
           this.beep=beep;
     }

     ...

      public class TimePrinter(){

            public printTime(){
               if (beep){
                  Date now = new Date();
                  System.out.println("current is : " + now);
               }
            }
      }

}

注： 内部类会在编译的时候修改内部类默认的构造器，如下，并且在调用的时候将外部类传递进去

public class TimePrinter(){

      public TimePrinter(TalkingClock tc){
                  outer = tc;
      }                

}

// pass outer object reference
TimePrinter tp = new TimePrinter(this)

二、当内部类定义为 Public 时，可以创建和引用内部类，语法如下：OuterClass.InnerClass

TalkingClock tc = new TalkingClock(10000, true);
tc.TimePrinter tp= tc. new TimePrinter();

局部内部类

顾名思义，在方法的内部定义的类。注：不能用修饰符【public,private】修饰它。举例：

public class OutClass{

    public void start(){
       class innerClass{
        ...
       }
       InnerClass ic = new InnerClass();
       Timmer t = new Timer(, ic);
       t.start();
    }

}

匿名内部类

// 定义了一个匿名类，它继承 object 类;
// 调用匿名类的 getClass() 方法
new Object{}.getClass();

静态内部类

当内部类不需要引用外部类的字段时，可将内部类定义成为 static 的

public class OutClass{
   static InnerClass{
        ...
   }
}