JavaSE知识点查漏补缺（2）

这篇博客我们将接着之前博客中的知识点继续对JavaSE的知识点进行回顾，查漏补缺

4、高级特性（很重要的一部分、必须搞懂）

继承 : 从现有类创建子类, 现有类称为父类, 基类, 超类(super)

子类继承父类所有成员(构造器除外) 
包括对象属性（实例变量）和对象方法（实例方法）

子类对象中包含的属性有从所有父类继承来的属性和子类特有的属性. 所以子类对象暗含父类对象

子类中可以包含和父类重复的成员
实例变量
实例方法 : 方法覆盖 : 1) 方法签名一致 2) 修饰符子类大于等于父类. 

class A {
Type1 field1;
Type2 field2;
}

class B extends A {
Type3 field3;
Type4 field4;
}

class C extends A {
Tupe5 field5;
}

new B();

子类可以继承父类的私有成员, 但是不能直接访问, 必须通过从父类继承的公共的方法间接访问.
方法重写 :在继承关系中, 子类中把从父类继承的方法覆盖, 父类中的方法被隐藏起来.
方法覆盖条件:
1) 方法签名一致, 返回值类型 方法名相同(参数列表相同)... 参数的顺序,个数,类型
2) 访问权限子类大于等于父类
子类对象的创建 : 1) 父类继承的属性和特有属性初始化, 在子类中不可以直接对从父类继承的私有属性进行初始化
通常需要借用父类的构造器完成初始化 super(...).
@Override 注解 : 告诉编译器,本方法将覆盖父类的方法, 请作检查!!

使用super关键字就是在子类中特别指定一些从父类继承来的成员的访问, super.成员名, 可以一直向上追溯

还可以显式地调用父类的构造器 super(...), 但是只限于直接父类的构造器的调用 
关于构造器 
1) 所有类都必须有构造器
2) 所有类的构造器都必须有对父类构造器的调用
1) 子类构造器中的第一行会有隐式的父类构造器的直接调用
2) super(...)作用是在子类构造器中直接显式地调用父类构造器 this(...)作用是在子类构造器中间接地隐式地调用父类构造器

<span style="white-space:pre">	</span>class A {
A() {}
}

class B extends A {
Type field1;
B(Type field1) {
super();
this.field1 = field1;
}
}

class C extends B {
C() {
super();
}
}

多态 :一个对象的多种父类类型的形态.

多态引用 : 子类对象的引用赋值于父类类型的引用变量.

多态副作用 :不可以再访问子类特有的成员
虚拟方法调用 :
在多态环境下, 调用覆盖方法.
1)编译时检查父类类型

2)运行时方法实际绑定的是子类

创建多态数组, 数组中就可以保存任意子类对象

Object[] objArr = new Object[10];

多态参数

public boolean equals(Object obj) {
// 访问特有成员时
if (obj instanceof 子类类型) {
子类类型 引用 = (子类类型)obj;
引用.特有成员;
}
}

static :可以修饰内部类, 成员变量, 成员方法
成员变量 :
1) 实例变量 对象属性 必须依赖对象的存在而存在 存储空间在GC区中 int a;  
2) 类变量 类属性  不必依赖对象的存在而存在, 只依赖于类的存在而存在 存储空间在永久区中
成员方法 :
1) 实例方法 对象方法 它的调用必须依赖于对象, 存储空间在永久区中的类模板定义中
2) 类方法 静态方法 它的调用不依赖对象, 调用只依赖于类, 存储空间在永久区中的类模板定义中
类模板 :
1) 成员变量和所有方法的定义
2) 类变量的存储空间 
3) 构造器方法
4) 代码块
5) 类名, 类所属的包, 类的父类
一旦被static修饰,意味着成员隶属于类, 只需要类就可以使用, 但是通过对象仍然也可以, 因为对象归属于类
final:可以修饰类, 方法, 属性, 变量
修饰类表明这个类是终结类(完美类), 不允许被扩展(不允许被继承)
修饰方法 表明这个方法是最终方法, 不允许被子类扩展(不允许被重写)
修饰变量 表明这个量是final量, 只允许赋值一次, 再不允许赋值了.

空final量 : final修饰属性时没有直接显式赋值.
必须保证对其进行一次赋值, 非静态空final量可以在所有构造器中 或 动态代码块中
具体类 :对一种事物的抽象定义

抽象类 :同一类型的不同种事物的抽象定义
被abstract修饰, 并且可以包含抽象方法(被abstract修饰, 没有方法体)
具体类不能包含抽象方法
抽象类可以包含抽象方法.
抽象类不能创建对象, 必须包含构造器, 子类调用
抽象类专门用于被继承.
抽象类体现的是模板设计
接口 : 只关心行为.

接口中包含的全部是抽象方法, 全局常量.

使用interface定义的接口可以继承接口, 并且允许多继承

接口(父类)用途主要是被类(子类)实现,使用关键字implements 

class 类 extends 父类 implements 接口1, 接口2, 接口3.... {

}
框架 : 其中有大量的接口, 用于制定规范, 抽象类作模板, 还有一些具体类, 实现了接口.

面向接口 :只关心接口定义的规范, 具体子类无关性

内部类 :一个类的定义位于另外一个类的内部.

/*class 外部类 {
private Type1 field1;
private Type2 field2;
prviate 内部类 引用 = new 内部类(); // 通过引用可以访问内部类的所有成员, 包括私有成员

public class 内部类 { // 内部类通常会设计成GUI中的事件监听器, 内部类作为一个线程
在内部类中的任意位置, 直接访问外部的所有成员,包括私有成员.
}

public static class 嵌套类 {
在嵌套类中的任意位置, 直接访问外部的所有静态成员,包括私有成员.
}
}
测试类 {
main() {
外部类.内部类 引用 = new 外部类().new 内部类();
外部类.嵌套类 引用 = new 外部类.嵌套类();

//局部内部类  在方法中定义类
// 方法内定义类
class 类 {}
// 匿名内部类
类 引用 = new 类的构造器(实参) {
// 类体就是类的子类
};
引用.方法(); // 多态.
}
}*/

对象之间的关系 :

0) 对象聚集:类型[] 对象数组;

1) 对象作为参数
void method(类型 对象) {
}

2) 对象关联
类 {
另外类 对象;
}

3) 继承

5、这一部分是比较简单的枚举&注解

枚举 : 一个类的对象的个数是可数的,可枚举的.

/*enum(eration) 枚举名 {
常量对象1, 常量对象2, 常量对象3...
}
main() {
枚举名 引用 = 枚举名.常量对象名;
switch(引用) {
case 常量对象1 :
....
}
枚举名[] 对象数组 = 枚举名.values();
}*/

注解: 给运行环境看的注释性的一种对象

定义:

@Target(此注解可以用于什么位置)

@Retention(此注解可以存活到什么时候) 

@interface 注解名 {
Type 属性() default 缺省值;

}

使用:

@注解名(属性=值, 属性2=值2...)

目标

5、异常处理、常用类

异常 : 在程序运行时出现的非正常状况.

异常在栈中以对象的形式抛出

异常对象是Throwable的子类对象, 当前方法不能继续执行, 提前返回, 并且把异常抛出给调用者, 对调用者产生破坏性影响.

异常分类 :
1) 受检异常 : 程序中必须对其进行处理的异常
Exception及其子类(除RuntimeException及其子类)
2) 非受检异常 : 程序中可以不对其进行处理的异常
1) Error及其子类
2) RuntimeException及其子类

异常处理 :

<span style="white-space:pre">	</span>/*1) 捕获 try catch [finally]
try {
可能抛出异常的语句块;
} catch (异常类型1 对象) {
处理异常对象;
} catch (异常类型2 对象) {
处理异常对象2;
} .....
finally {
必须会被执行的语句, 通常作一些释放不在GC区中的资源的操作
}

组合 : try catch
try catch finally
try finally*/

2) 抛出:在方法声明中使用throws 异常类型1, 异常类型2 ... 在方法体中使用了throw 异常对象;
3) 捕获再抛出:在方法中先捕获一个已知异常对象, 再把这个异常对象包装成别的异常对象, 再抛出别的异常对象.

处理方式选择 :
被调用的方法尽可能抛出异常
处于栈底的方法尽可能捕获异常

方法覆盖条件 :
1) 方法签名一致
2) 访问控制修饰符子类大于等于父类
3) 抛出的受检异常子类要小于等于父类
包装类:把基本数据类型包装成对象类型.
byte Byte
short Short
char Character
int Integer
long Long
float Float
double
Double
boolean
Boolean
装箱 : 使用构造器(基本数据类型)
构造器(字符串类型)
两种 : 手工装箱, 使用构造器
自动装箱, 包装类 引用 = 基本数据值;

拆箱两种方式:
手工拆箱 : 引用.xxxValue(); 
自动拆箱 : 基本数据类型 变量 = 引用;

字符串到基本数据类型转换 :包装类.parseXxx(String); 

基本数据类型到字符串
基本数据值 + ""
String.valueOf(基本数据值)
包装类.toString(基本数据值)

字符串 :
String :内容不可改变的Unicode字符序列. 任何对String内容的修改都将导致产生新的字符串对象.
构造器 :
String(String s) 
String(char[] arr)
String(char[] arr, int offset, int count) ; 从下标offset开始,总共count个字符
方法：
int length();
char charAt(int index);
int indexOf(String child); indexOf(String child, int start)
int lastIndexOf(String child) lastIndexOf(String child, int start)
String substring(int beginIndex, int endIndex); endIndex-beginIndex个字符
String substring(int beginIndex)
boolean startsWith(String child), boolean endsWith(String child)
String trim();
char[] toCharArray();
String[] split(String child)
String toUpperCase(), String toLowerCase()
String replace(char oldCh, char newCh); String replaceAll(String oldStr, String newStr);
String concat(String str);
boolean contains(String child);

StringBuilder
: 效率高, 线程不安全
StringBuffer : 效率低, 线程安全
内容可以改变的Unicode字符序列
以上两个类中的方法全部都一样
对象自身 append(...); 可以追加任意内容
对象自身 insert(int index, ...)
对象自身 delete(int beginIndex, int endIndex);

Data类、Math类也可能会用到，大家了解了解常用方法就可以了。