javaSE/oop.md · 万孝国/java_study

# 简介
面向对象程序设计特征
+ 所有东西都是对象。可将对象想象成一种新型变量；它保存着数据，但可要求它对自身进行操作。理论上讲，可从要解决的问题身上提出所有概念性的组件，然后在程序中将其表达为一个对象
+ 程序是一大堆对象的组合；通过消息传递，各对象知道自己该做些什么。可将消息想象为一个调用请求，它调用的是从属于目标对象的一个子例程或函数
+ 每个对象都有自己的存储空间，可容纳其他对象，通过封装现有对象，可制作出新型对象
+ 每个对象都有一种类型
+ 同一类所有对象都能接收相同的消息

## null
+ 引用本身存储的对象的地址信息（虽然与指针不是完全相同），而这个地址信息是存储在栈中的，在声明后就会立刻在栈上给分配存储空间
+ 在方法调用传递引用的时候，对形参引用的值本身所做的修改对实参不可见，因此，从本质上来讲，引用也是原始数据类型（Primitive）
+ 虽然引用在底层是通过指针实现的，但是引用和指针不能等同，例如指针可以执行比较运算和整数加减运算，而引用却不行
+ 在 Java 语言中，给任何对象赋值为 null 都是合法的， null 可以被强制转换为任意类型的对象，转换的结果还是 null，因此，无法调用对象的方法，但是可以调用类的方法（因为类的方法是不依赖于对象而存在的）。
```java
public class Test{
public static void hello() {System.out.println("hello"); }
public static void main(String[] args) { ((Test) null).hello(); } } // 能正常运行
```

# class
类(class)是构造对象的模板或蓝图，类中有且仅有5大成分
- 成员变量`Field`：描述类或者对象的属性信息的
- 成员方法`Method`：描述类或者对象的行为的
- 构造器（构造方法,`Constructor`）: 初始化类的一个对象返回
- 代码块：代码块按照有无static可以分为**静态代码块**和**实例代码块**
- **内部类**：将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类

```java
[< 修饰符>] class < 类名> {
  [<属性声明> [修饰符]  属性类型  属性名 = [默认值];]
	[<构造器声明>]
	[<方法声明>]
}
```

访问修饰符
+ public: 表示任何类都可以访问
+ 包访问权限: 包访问权限，没有任何关键字。它表示当前包中的所有其他类都可以访问，但是其它包的类无法访问
+ protected: 表示子类可以访问，此外，同一个包内的其他类也可以访问，即使这些类不是子类
+ private: 表示其它任何类都无法访问

使用 new 构造方法 创建一个新的对象, 使用`对象名.对象成员` 的方式访问对象成员（包括属性和方法）
+ 在一个类中的访问机制：类中的方法可以直接访问类中的成员变量。（有一个例外）
+ 在不同类中的访问机制：先创建要访问类的对象，再用对象访问类中定义的成员
+ 当一个对象被创建时，会对其中各种类型的成员变量自动进行初始化赋值
+ 也可以不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫做匿名对象

## 构造方法
+ 构造器也叫构造方法(constructor)，用于对象的初始化，具有与类相同的名称，它不含返回值
+ Java通过new关键字来调用构造器，从而返回该类的实例，是一种特殊的方法
+ 构造方法的作用：当一个类的实例对象刚产生时，这个类的构造方法就会被自动调用，可以在这个方法中加入要完成初始化工作的代码
+ 一旦显式定义了构造方法，则系统不再提供默认构造方法
+ 构造方法是创建Java对象的重要途径，通过new关键字调用构造器时，构造器也确实返回该类的对象，但这个对象并不是完全由构造器负责创建
+ **创建一个对象**分为如下四步： 
  + 分配对象空间，并将对象成员变量初始化
  + 执行属性值的显示初始化
  + 执行构造方法
  + 返回对象的地址给相关的变量

## this关键字
this的本质就是 **创建好的对象的地址** 由于在构造方法调用前，对象已经创建。因此，在构造方法中也可以使用this代表当前对象
+ 每个成员方法内部，都有一个this引用变量，指向调用这个方法的对象
+ 在程序中产生二义性之处，应使用this来指明当前对象;普通方法中，this总是指向调用该方法的对象
+ 使用this关键字调用重载的构造方法`this()`，避免相同的初始化代码。但只能在构造方法中用，并且必须**位于构造方法的第一句**
  
## static关键字
static标记的变量或方法由整个类(所有实例)共享，如访问控制权限允许，可不必创建该类对象而直接用类名加`.`调用
+ static成员也称类成员或静态成员，如：类变量、类方法、静态方法等,不能修饰局部变量
变量（类属性）由该类的所有实例共享。静态变量既能被对象调用，也能直接拿类来调用
+ 在static方法内部只能访问类的static属性，不能访问类的非static属性, 在普通成员方法中，则可以直接访问同类的非静态变量和静态变量

一个类中可以使用不包含在任何方法体中的**静态代码块**(static block ):
+ 当类被载入时，静态代码块被执行，且只被执行一次，静态块经常用来进行类属性的初始化
+ 静态初始化块执行顺序:上溯到Object类，先执行Object的静态初始化块，再向下执行子类的静态初始化块，直到类的静态初始化块为止(构造方法执行顺序一样)
+ 能继承和覆盖，但覆盖 static 方法必须也是 static 的方法
+ 不加static为动态初始化代码块，在创建对象时被调用(在构造函数之前)

```java
class Person {
	public static int total;
	static {
    total = 100;//为total赋初值 
	}
	…… //其它属性或方法声明
}
```

static变量和普通成员变量主要有以下4点区别：
- 区别1：所属不同。static变量属于类，不单属于任何对象；普通成员变量属于某个对象
- 区别2：存储区域不同。static变量位于方法区；普通成员变量位于堆区
- 区别3：生命周期不同。static变量生命周期与类的生命周期相同；普通成员变量和其所属的对象的生命周期相同
- 区别4：在对象序列化时（Serializable），static变量会被排除在外（因为static变量是属于类的，不属于对象）

## final关键字
final标记的变量(成员变量或局部变量)即成为常量，只能赋值一次
+ 须在声明的同时或在每个构造方法中显式赋值，对于在构造方法中利用final进行赋值时，此时在构造之前系统设置的默认值相对于构造方法失效
+ 当final修饰实例变量时，实例变量不会自动初始化为0；但必须给他赋值才能通过编译
+ 成员变量涉及到初始化的问题，初始化方式有显示初始化和构造器初始化，只能选择其中一个

修饰对象
+ final标记的类不能被继承。提高安全性，提高程序的可读性
+ final标记的方法不能被子类重写,但是可以被重载。增加安全性，private 和 static 方法默认均为 final 方法
+ final修饰的对象，对象的引用地址不能变，但是对象的值可以变
  
局部内部类和匿名内部类只能访问局部final变量
+ 内部类和外部类是处于同一个级别的，内部类不会因为定义在方法中就会随着方法的执行完毕就被销毁
+ 局部变量会复制了一份作为内部类的成员变量，这样当局部变量死亡后，内部类仍可以访问它
+ 将局部变量设置为final，保证了内部类的成员变量和方法的局部变量的一致性。这实际上也是一种妥协。使得局部变量与内部类内建立的拷贝保持一致

### 关于 final 的设计模式：不变模式
不变模式：一个对象一旦产生就不可能再修改( string 就是典型的不变模式)； 通过不变模式可以做到对象共享

池化思想：用一个存储区域来存放一些公用资源以减少存储空间的开销
+ 有池的类型:boolean,byte,int,short,long,char,(池范围在-127~128之间)
+ 在String类中有个串池(在代码区)
+ 池：堆里的一片独立空间。目的是拿空间换时间，让运算效率更高

## 方法
方法用于定义该类或该类的实例的行为特征和功能实现, 是类和对象行为特征的抽象, 类似于面向过程中的函数

方法的调用方式： **对象名.方法名(实参列表)**
+ **形式参数**：在方法声明时用于接收外界传入的数据
+ **实参**：调用方法时实际传给方法的数据
+ **返回值**：方法在执行完毕后返还给调用它的环境的数据
+ **返回值类型**：事先约定的返回值的数据类型，如无返回值，必须显示指定为为void

```java
[修饰符1  修饰符2  …] 返回值类型  方法名(形式参数列表){
  Java语句；… … …
  return 返回值;
}
```

### 求值策略
**求值策略（Evaluation strategies）**：确定编程语言中表达式的求值的一组（通常确定性的）规则，定义何时和以何种顺序求值给函数的实际参数、什么时候把它们代换入函数、和代换以何种形式发生

求值策略分为两大基本类，基于如何处理给函数的实际参数，分为严格的和非严格的
+ 在“严格求值”中，函数调用过程中，给函数的实际参数总是在应用这个函数之前求值
+ 在严格求值中有几个关键的求值策略
  + 传值调用（值传递） : 实际参数先被求值，然后其值通过复制，被传递给被调函数的形式参数, 并不会改变实际参数的值
  + 传引用调用（引用传递） : 传递给函数的是它的实际参数的隐式引用而不是实参的拷贝，改变对于调用者来说是可见的
  + 传共享对象调用（共享对象传递）: 先获取到实际参数的地址，然后将其复制，并把该地址的拷贝传递给被调函数的形式参数
    * 因为参数的地址都指向同一个对象，也称之为"传共享对象"
    * 如果在被调函数中改变了形式参数的值，调用者是可以看到这种变化的
    * 通常认为传共享对象调用是传值调用的特例

```java
/**
 * （1）形参是基本数据类型的传递数据值
 * （2）形参是引用数据类型的: 传递地址值 特殊的类型：String、包装类等对象不可变性
 */
public class Test {
  public static void main(String[] args) {
    int i = 1;
    String str = "hello";
    Integer num = 200;
    int[] arr = {1, 2, 3, 4, 5};
    MyData my = new MyData();
    change(i, str, num, arr, my);
    System.out.println("i = " + i); // 1
    System.out.println("str = " + str); // hello
    System.out.println("num = " + num); // 200
    System.out.println("arr = " + Arrays.toString(arr)); // [2,2,3,4,5]
    System.out.println("my.a = " + my.a); // 11
  }
  public static void change(int i, String str, Integer num, int[] arr, MyData my) {
    i += 1;
    str += "world";
    num += 1;
    arr[0] += 1;
    my.a += 1;
  }
}
class MyData {
  int a = 10;
}
```

### 方法的重载
方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法, 调用时，会根据不同的参数自动匹配对应的方法
构成方法重载的条件：形参类型、形参个数、形参顺序不同，方法返回值和访问修饰符可以相同

### 方法重写
重写发生在运行期，是子类对父类的允许访问的方法的实现过程进行重新编写。构造方法无法被重写
+ 方法名、参数列表必须相同
+ 子类方法返回值类型应比父类方法返回值类型更小或相等
+ 抛出的异常范围小于等于父类
+ 访问修饰符范围大于等于父类
+ 如果父类方法访问修饰符为 private/final/static 则子类就不能重写该方法，但是被 static 修饰的方法能够被再次声明。

### 可变参数
可变参数的形式  `...`
可变参数只能是方法的形参，且最多有一个，只能是最后一个
可变参数对应的实参可以有多个，也可以是一个数组，并将可变参数当做数组来处理
如果定义了可变参数的方法，不允许同时定义相同类型数组参数的方法
优先匹配固定参数的方法
+ 数组做形参和可变参数做形参联系
  + 实参都可以是数组；
  + 方法体中，可变参数当做数组来处理
+ 区别
  + 个数不同 可变参数只能有一个数组参数可以多个
  + 位置不同 可变参数只能是最后一个 数组参数位置任意
  + 实参不同 可变参数实参可以0,1,2.....个，也可以是一个数组，数组的实参只能是数组

```java
public static void func(String... args) {
    for (String s : args) {}
}
```

## 代码块
代码块(或初始化块)的`作用`： 对Java类或对象进行初始化
- 一个类中代码块若有修饰符，则只能被static修饰，称为静态代码块(static block)
- 没有使用static修饰的，为非静态代码块

### 静态代码块
+ 可以有输出语句
+ 可以对类的属性、类的声明进行初始化操作
+ 不可以对非静态的属性初始化。即：不可以调用非静态的属性和方法
+ 若有多个静态的代码块，那么按照从上到下的顺序依次执行
+ 静态代码块的执行要先于非静态代码块
+ 静态代码块随着类的加载而加载，且只执行一次

### 非静态代码块
如果多个重载的构造器有公共代码，并且这些代码都是先于构造器其他代码执行的，那么可以将这部分代码抽取到非静态代码块中，减少冗余代码
+ 可以有输出语句。
+ 可以对类的属性、类的声明进行初始化操作
+ 除了调用非静态的结构外，还可以调用静态的变量或方法
+ 若有多个非静态的代码块，那么按照从上到下的顺序依次执行
+ 每次创建对象的时候，都会执行一次。且先于构造器执行

# 类的继承
Java只支持单继承，不允许多重继承，接口有多继承，父类也称作超类、基类、子类也叫派生类等
+ 如果定义一个类时，没有调用extends，则它的父类是：**java.lang.Object**
+ 子类继承父类，可以得到父类的全部属性和方法 (除了父类的构造方法)，但不见得可以直接访问(比如，父类私有的属性和方法)
+ **instanceof**是二元运算符，左边是对象，右边是类；当对象是右面类或子类所创建对象时，返回true；否则，返回false
  
```java
< 修饰符> class < 子类名称> [extends < 父类>] {
  <属性和方法的声明>
}
```

## super关键字
super是直接父类对象的引用,可以通过super来访问父类中被子类覆盖的方法或属性
+ 使用super调用普通方法，语句没有位置限制，可以在子类中随便调用
+ 若是构造方法的第一行代码没有显式的调用super(...)或者this(...);那么Java默认都会调用super(),含义是调用父类的无参数构造方法

属性/方法查找顺序：(比如：查找变量h)
+ 查找当前类中有没有属性h
+ 依次上溯每个父类，查看每个父类中是否有h，直到Object
+ 如果没找到，则出现编译错误
+ 上面步骤，只要找到h变量，则这个过程终止

## java继承中的问题
类初始化过程
+ 一个类要创建实例需要先加载并初始化该类
+ 一个子类要初始化需要先初始化父类
+ 一个类初始化就是执行cinit()方法
  + cinit()方法由静态类变量显示赋值代码和静态代码块组成
  + 类变量显示赋值代码和静态代码块代码从上到下顺序执行
  + cinit()方法只执行一次
```java
public class Main {
  public static void main(String []agrs) {
    base b = new son();
    System.out.println(b.num);
    System.out.println(b.fun1());
    b.show();
    System.out.println(((son)b).fun2());
  }
}

class base{
  public String num="父类成员变量";
  public String fun1() {
    System.out.println(this.num);
    return "父类调用";
  }
  public void show() {
    System.out.println(this.num);
    System.out.println(this.fun1());
  }
}

class son extends base{
  public String num="子类成员变量";
  public String fun1() {
    System.out.println(this.num);
    return "子类调用";
  }
  public String fun2() {
    return "子类特有方法";
  }
}
/*
输出：//后面为解释
父类成员变量 // 变量没有多态
子类成员变量 // 对于方法的覆盖 ， new谁就调用谁。 多态 this本类中的属性
子类调用 
父类成员变量 // 对于变量的覆盖，this在哪个类就调用哪个类。
子类成员变量  //对于方法的覆盖 ， new谁就调用谁。
子类调用
子类特有方法
*/
```

```java
class Father {
	int x =10;
	public Father(){
		this.print();
		x  = 20;
	}
	public void  print (){
		System.out.println("Father.x = "+x);
	}
}

public  class  Son extends  Father {
	int x = 30;
	public Son(){
		this.print();
		x = 40;
	}
	public void print() {
		System.out.println("Son.x = "+x);
	}
	public static void main(String[] args) {
		Father f = new Son();
		System.out.println(f.x);
	}
}
/*
输出：
Son.x = 0  // 子类new的时候需要调用父类的构造函数，此时this是指向子类的，但子类的x完成默认初始化
Son.x = 30 // 返回子类后，子类x完成显式初始化，
20 // 成员变量没有动态性
*/
```

## 重载(Overload) 与 覆盖
在同一个类中，允许同时存在一个以上的同名函数，只要他们的参数列表不同即可
+ 方法重载时，对于参数的匹配有个向上就近原则
+ 方法的重载使同一类方法由于参数造成的差异对于对象的使用者是透明的
+ java中唯一重载的运算符是String类型的“+”号
+ 重载不仅出现在同一个类中，也可以出现在父子类中

在子类中可以根据需要对从父类中继承来的方法进行改造—覆盖方法(方法的重置、重写)，在程序执行时，子类的方法将覆盖父类的方法
+ 覆盖方法必须和被覆盖方法具有相同的方法名称、参数列表和返回值类型
+ 覆盖方法不能使用比被覆盖方法更严格的访问权限。子类大于等于父类
+ 返回值类型和声明异常类型，子类小于等于父类

# 多态性
+ 多态在Java中，子类的对象可以替代父类的对象使用，多态是方法的多态，不是属性的多态(多态与属性无关)
+ 多态的存在要有3个必要条件：继承，方法重写，父类引用指向子类对象
+ 父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了
+ 多态分为两种：编译时多态（重载）和运行时多态（覆盖）

## 对象类型转换
+ 对Java对象的强制类型转换称为造型（转型）
+ 从子类到父类的类型转换可以自动进行
+ 从父类到子类的类型转换必须通过造型(强制类型转换)实现
+ 无继承关系的引用类型间的转换是非法的
+ 在造型前可以使用instanceof操作符测试一个对象的类型

# 包
包机制是Java中管理类的重要手段。解决类重名的问题，也可以实现对类的有效管理。 包对于类，相当于文件夹对于文件的作用。
通过package实现对类的管理，package的使用有两个要点：
+ 通常是类的第一句非注释性语句。
+ 包名：域名倒着写即可，再加上模块名，便于内部管理类。

要使用其他包的类，需要使用import导入，从而可以在本类中直接通过类名来调用，否则就需要书写类的完整包名和类名。
Java会默认导入java.lang包下所有的类，因此这些类我们可以直接使用。
如果导入两个同名的类，只能用包名+类名来显示调用相关类：

**静态导入**(static import)是在JDK1.5新增加的功能，其作用是用于导入指定类的静态属性，用来直接使用静态属性。

Java编译器最终编译出的.class文件只使用完整类名，因此，在代码中，当编译器遇到一个class名称时：
+ 如果是完整类名，就直接根据完整类名查找这个class
+ 如果是简单类名，按下面的顺序依次查找：
  + 查找当前package是否存在这个class
  + 查找import的包是否包含这个class
  + 查找java.lang包是否包含这个class

```java
import java.sql.Date;
import java.util.*;//导入该包下所有的类。会降低编译速度，但不会降低运行速度。
import static java.lang.Math.*;//导入Math类的所有静态属性
import static java.lang.Math.PI;//导入Math类的PI属性
 
public class Test{
  public static void main(String[] args) {
    Date now; // 这里指的是java.sql.Date
    // java.util.Date因为和java.sql.Date类同名，需要完整路径
    java.util.Date now2 = new java.util.Date();
    // java.util包的非同名类不需要完整路径
    Scanner input = new Scanner(System.in);    
  }
}
```

# 抽象类abstract
用 `abstract` 关键字来修饰一个类时，这个类叫做抽象类；修饰一个方法时，该方法叫做抽象方法
+ 抽象方法：只有方法的声明，没有方法的实现,以分号结束，含有抽象方法的类必须被声明为抽象类
+ 抽象类不能被实例化，抽象类是用来被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体
+ 不能用abstract修饰私有方法，构造方法，静态方法，本地方法，synchronized，原因与具体实现细节有关

# 接口interface
接口(interface)是抽象方法和常量值的定义的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法
+ 接口的访问权限修饰符为public、default,接口可以用abstract修饰
+ 接口中的所有成员变量都默认是由**public static final**修饰的
+ 接口中的所有方法都默认是由**public abstract**修饰的。接口没有构造方法

## 接口与抽象类的区别
共同点：
+ 都不能被实例化
+ 都可以包含抽象方法
+ 都可以有默认实现的方法（Java 8 可以用 default 关键字在接口中定义默认方法）

区别：
+ 接口主要用于对类的行为进行约束，实现了某个接口就具有了对应的行为
+ 抽象类主要用于代码复用，强调的是所属关系。一个类只能继承一个类，但是可以实现多个接口
+ 接口中的成员变量不能被修改且必须有初始值，而抽象类的成员变量默认 default，可在子类中被重新定义，也可被重新赋值

## 接口默认方法和静态方法
Java8开始，接口中新增的方法可以不需要实现类必须实现，因为接口支持两种新类型的方法及其实现
+ 静态方法，通过`static`关键字标识，表示这个方法可以通过接口直接调用，这个方法时是属于该接口的
+ 默认方法，通过`default`关键字标识，并且接口提供了方法的默认实现，实现接口的类如果不显式地提供该方法的具体实现
+ 私有方法：使用 `private` 修饰，供接口中的默认方法或者静态方法调用
+ 实际上静态方法和默认方法被大量的用来支持lambda表达式的复杂写法与复合逻辑
+ 子接口重写默认方法时，default关键字可以保留，实现类重写默认方法时，default关键字不可以保留。

```java
public interface ITest {
  static void test1() {
    System.out.println("test1" + ITest.class);
  }

default void test2() {
    System.out.println("test2" + ITest.class);
  }
}
```

## 多重实现的冲突
菱形继承问题：即有个接口A，有个默认方法a()，此时子接口B、C继承了A接口，随后实现类D同时实现了B、C接口，此时在D中调用a()方法不会有问题，但是c++就有问题！

一个类可以实现多个接口，即使有同名方法也没关系，因此抽象方法没有具体的行为，子类必须有针对抽象方法自己的实现, Java8接口允许了默认方法之后，Java已经在某种程度上实现了多继承
+ 本类重写的方法优先级最高
+ 否则，一个类同时实现了类或者接口，并且类和接口具有相同的签名的方法，那么父类中声明的方法的优先级高于任何接口中声明的默认方法的优先级
+ 否则，那么子接口的优先级更高：函数签名相同时，优先选择拥有最具体实现的默认方法的接口，即如果B接口继承了A接口，那么B接口就比A更加具体
+ 否则，继承了多个接口的类必须显式指定的调用某个父接口的默认方法实现

# 内部类
一般情况，把类定义成独立的单元。有些情况下把一个类放在另一个类的内部定义，称为内部类(innerClasses)
+ 内部类只是一个编译时概念，一旦编译成功，就会成为完全不同的两个类
+ 对于一个名为Outer的外部类和其内部定义的名为Inner的内部类
+ 编译完成后会出现Outer.class和Outer$Inner.class两个类的字节码文件
+ 所以内部类是相对独立的一种存在，其成员变量/方法名可以和外部类的相同

内部类配合接口使用,来强制做到弱耦合
+ 内部类存在的意义在于可以自由的访问外部类的任何成员(包括私有成员),但外部类不能直接访问内部类的
+ 内部类可以使用public、default、protected 、private以及static修饰
+ Inner class可以声明为抽象类 ，因此可以被其它的内部类继承。也可以声明为final的
+ 和外层类不同，Inner class可以声明为private或protected；
+ Inner class 可以声明为static的，但此时就不能再使用外层封装类的非static的成员变量；
+ 非static的内部类中的成员不能声明为static的，只有在顶层类或static的内部类中才可声明static成员；
+ 在Java中内部类主要分为成员内部类(非静态内部类、静态内部类)、匿名内部类、局部内部类

**创建静态内部类对象的一般形式为： 外部类类名.内部类类名 xxx = new 外部类类名.内部类类名()**
**创建成员内部类对象的一般形式为： 外部类类名.内部类类名 xxx = 外部类对象名.new 内部类类名()**

## 成员内部类
+ 成员内部类(实例内部类)：作为外部类的一个成员存在，与外部类的属性、方法并列。
+ 成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）
+ 成员内部类可看作外部类的实例变量。在内部类中访问实例变量：**this.属性**
+ 在内部类访问外部类的实例变量：**外部类名.this.属性。**
+ 建立内部类对象时应注意：
  + 在创建成员内部类的实例时，外部类的实例必须存在
  + 在外部类的内部可以直接使用 `inner s=new inner();`  因为外部类知道 inner 是哪个类
  + 而在外部类的外部，要生成一个内部类对象，需要通过外部类对象生成。

```java
class Circle {
  double radius = 0;
  public Circle(double radius) {
    this.radius = radius;
  }
  class Draw {     //内部类
    public void drawSahpe() {
      System.out.println("drawshape");
    }
  }
}
```
成员内部类的继承问题  
+ 成员内部类的引用方式必须为 `Outter.Inner.`
+ 构造器中必须有指向外部类对象的引用，并通过这个引用调用`super()`

```java
class WithInner {
  class Inner{ }
}
class InheritInner extends WithInner.Inner {
  // InheritInner() 是不能通过编译的，一定要加上形参
  InheritInner(WithInner wi) {
    wi.super(); //必须有这句调用
  }
  public static void main(String[] args) {
    WithInner wi = new WithInner();
    InheritInner obj = new InheritInner(wi);
  }
}
```

## 匿名内部类
匿名内部类是没有名字的内部类,不能继承其它类,但一个内部类可以作为一个接口,由另一个内部类实现
+ 由于匿名内部类没有名字，所以它没有构造函数。因为没有构造函数，所以它必须完全借用父类的构造函数来实例化
+ 在匿名内部类里创建新的方法没有太大意义，但它可以通过覆盖父类的方法达到神奇效果
+ 因为匿名内部类没有名字，所以无法进行向下的强制类型转换，持有对一个匿名内部类对象引用的变量类型一定是它的直接或间接父类类型

```java
public class test{
  public static void main(String[] args){
    B.print(new A(){
    public void getConnection(){ System.out.println("Connection....");}  });
  }
}

interface A{ void getConnection();}
class B{
  public static void print(A a){ a.getConnection();}
}

//新建一个列表并赋初值A、B
ArrayList<String> list = new ArrayList<String>() {{
  add("A");
  add("B");
}}; 
/*第一层花括号定义了一个继承于ArrayList的匿名内部类 
  第二层花括号实际上是这个匿名内部类实例初始化块 (Instance Initializer Block)（或称为非静态初始化块）
  通过new得到这个ArrayList的子类的实例并向上转型为ArrayList的引用
  得到的实际上是一个ArrayList的子类的引用，虽然这个子类相比ArrayList并没有任何功能上的改变
  可以认为这是个本身装有数据的子类（因为它的数据来自于自身的初始化），而不是取得引用后再赋值
  这种方法一定程度上使代码更简洁，但同时可能降低可读性；还可能会造成内存泄露，在序列化时可能也会出现一些问题 */
```

## 静态内部类
+ 静态内部类定义在类中，在任何方法外，用 static 定义
+ 静态内部类不需要有指向外部类的引用。但非静态内部类需要持有对外部类的引用
+ 静态内部类可以有静态成员(方法，属性)，而非静态内部类则不能有静态成员(方法，属性)
+ 非静态内部类能够访问外部类的静态和非静态成员。静态内部类不能访问外部类的非静态成员，只能访问外部类的静态成员

```java
public class Test {
  public static void main(String[] args)  {
    Outter.Inner inner = new Outter.Inner();
  }
}
class Outter {
  static class Inner {}
}
```

## 局部内部类
局部内部类：在方法中定义的内部类称为局部内部类
+ 类似局部变量，**不可加修饰符**，其范围为定义它的代码块
+ 可以访问外部类的所有成员，此外，还可以访问所在方法中的 final 类型的参数和变量
+ 在类外不可直接生成局部内部类(保证局部内部类对外是不可见的)
+ 要想使用局部内部类时需要生成对象，对象调用方法，在方法中才能调用其局部内部类
+ 局部内部类不能声明接口和枚举

```java
class People{}
class Man{
  public People getWoman(){
    class Woman extends People{   //局部内部类
      int age =0;
    }
    return new Woman();
  }
}
```

# Java创建对象的几种方式
+ (1) 用new语句创建对象，这是最常见的创建对象的方法。
+ (2) 运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法。
+ (3) 调用对象的clone()方法。
+ (4) 运用反序列化手段，调用java.io.ObjectInputStream对象的 readObject()方法
+ Unsafe 中提供 allocateInstance 方法，仅通过 Class 对象就可以创建此类的实例对象，而且不需要调用其构造函数、初始化代码、JVM 安全检查等

(1)和(2)都会明确的显式的调用构造函数 ；
(3)是在内存上对已有对象的影印，所以不会调用构造函数 ；(4)是从文件中还原类的对象，也不会调用构造函数。

## Builder
Builder 方式：要构建一个大型的对象，这个对象包含许多个参数的对象，有些参数有些是必填的，有些则是选填的
+ 需要用户手动的传入多个参数，并且有多个参数是可选的、顺序随意
+ 该对象是不可变的（所谓不可变，就是指对象一旦创建完成，其内部状态不可变
+ 不可变对象本质上是线程安全的
+ 对象所属的类不是为了继承而设计的
+ 优点：不需要写多个构造函数，使得对象的创建更加便捷

```java
public class Person {
  // 使用 final 修饰一旦被初始化就不能再改变，保证了对象的不可变性
  private final String name;// 姓名（必填）
  private final int age; // 年龄（必填）
  private final int height;// 身高（选填）
  private final String school;  // 毕业学校（选填）
  /*  1、成员变量的初始化。final 类型的变量必须进行初始化，否则无法编译成功
      2、 私有构造函数能够保证该对象无法从外部创建，并且 Person 类无法被继承 */
  private Person(String name, int age, int height, String school) {}
  /*
    构建器: 必须是 Person 的内部类。否则，由于 Person 的构造函数私有，不能通过 new 的方式创建 Person 对象
    必须是静态类。由于 Person 对象无法从外部创建，如果不是静态类，则外部无法引用 Builder 对象。
    Builder 内部成员变量要与 Person 的成员变量保持一致
  */ 
  public static class Builder {
    private String name;// 姓名（必填）。注意：这里不能是 final 的
    private int age; // 年龄（必填）
    private int height; // 身高（选填） 
    private String school; // 毕业学校（选填）
    public Builder(String name, int age){} 
    public Builder setHeight(int height) {
      this.height = height;
      return this;
    }// 其他可选属性同样使用set方法
    public Person build() {
      return new Person(name, age, height, school, hobby);
    } // 构建对象: 返回待构建的对象本身
  }
  public static void main(String[] args) {
    Person person = new Person.Builder("james", 12).setHeight(170).build(); // 通过链式调用的方式创建 Person 对象，非常优雅！
  }
}
```

万孝国/java_study

简介

发行版

贡献者

近期动态

万孝国/java_study .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

近期动态

搜索帮助

万孝国/java_study