JavaSE复习总结(三)

JavaSE复习总结

继承

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

1.子类继承父类的所有成员（构造器除外）所有成员包括对象属性和对象方法(私有的也继承)
2.子类不能直接访问父类的私有成员。（可以通过公共的方法进行间接访问）
3.单继承（一个子类只能有一个直接父类）

class A {
Type1 field1;
Type2 field2;
}

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

class C extends A {
Tupe5 field5;
}

new B();

super关键字（可以用于访问父类的成员，子类的构造方法默认调用父类的构造方法）
利用super关键字在构造器中完成对从父类继承来的私有属性进行初始化
父类内存空间的标示

构造器：子类的构造器会默认调用父类的无参构造器（利用super关键字）
若父类没有无参构造器，必须通过this调用本类的构造器，或者利用super调用父类的有参构造器，否则编译出错
意思说，子类必须调用父类构造器（不管怎样调，子类构造器中至少有一个构造器直接调用父类构造器，否则形成递归） 一句话，任何类都必须有构造器
任何类都必须有对父类构造器的调用

构造器和super关键字总结:
构造器: 1.所有类都必须有构造器
2.所有子类构造器都必须有对父类构造器的调用
3.子类构造器第一行会有隐式的父类构造器的直接调用

     super：1.可用于访问父类中的成员属性，调用父类的成员方法
            2.显式的调用直接父类构造器
        3.必须在第一行

class A {
A() {}
}

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

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

方法重写（override）
方法重写，在子类中根据需求重写从父类继承的方法。
@Override 注解 告诉编译器此处重写父类方法，请做检查

方法重写的条件：
1.方法名，返回类型，参数列表必须完全一样，才能构成方法重写
2.覆盖方法权限>=被覆盖的方法

子类对象内存中的创建过程：
1.检查永久区中有没有继承体系中的所有类的类模板（方法保存在类模板中，方法只有一份）
2.使用类加载器加载所有涉及的类到永久区中
3.根据类模板中的属性定义，从最父类—>最子类搜索，在GC区中开辟一块合适的内存空间
4.对该内存区域清0
5.查看属性有没有显式赋值，若有进行显式赋值，没有不执行
6.执行构造器初始化，从最父类—>最子类执行。
7.将对象的首地址赋值给子类对象的引用变量

子类对象中包含的属性有从父类继承来的属性和子类特有的属性，所以子类对象暗含父类对象
this：谁调用谁就是this

多态

多态—一个对象的多种父类形态

多态：子类对象被赋值给父类引用
本态：子类对象被赋值给本类引用

多态副作用：不可以访问子类特有的成员

Java程序执行过程有编译时类型，运行时类型
编译时类型，编译器在编译时只关注引用类型
运行时类型，此时程序怎么执行主要看对象

虚方法调用：
在多态环境下，调用覆盖方法
1)编译时检查父类类型
2)运行时实际绑定的是子类对象(动态绑定)

多态形成：
子类重写父类的某一方法，子类对象创建好后，将地址赋给父类引用，因为父类中有子类重写的方法，
这样可以欺骗编译器通过编译，然后在执行的时候主要是看对象，此时运行的是子类重写的方法。(虚方法调用)

多态应用：
1.(多态参数)将子类对象赋值给父类引用，这样将父类引用作为参数，就可以传入继承体系中的所有子类对象，
在方法中在对子类对象所属进行判断（a instanceof A —>对象a是不是类A的对象），进行造型，
(对象还原)然后调用重写的方法，可以形成多态(不同的子类对象得到不同的结果)（实参可以接收一个家族的任意对象）
public boolean equals(Object obj) {
// 访问特有成员时
if (obj instanceof 子类类型) {
子类类型 引用 = (子类类型)obj;
引用.特有成员;
}
}

2.创建父类类型数组:可以保存本类和所有子类的对象（多态数组）
Object[] objArr = new Object[10];
Object 类 equals方法 hashCode方法

static

类成员：
属性
方法
构造器
初始化块
内部类

static :
可以修饰内部类, 成员变量, 成员方法，代码块

成员变量 :
    1) 实例变量 对象属性 必须依赖对象的存在而存在 存储空间在GC区中 int a;  
    2) 类变量 类属性  不必依赖对象的存在而存在, 只依赖于类的存在而存在 存储空间在永久区中

成员方法 :
    1) 实例方法 对象方法 它的调用必须依赖于对象, 存储空间在永久区中的类模板定义中
    2) 类方法 静态方法 它的调用不依赖对象, 调用只依赖于类, 存储空间在永久区中的类模板定义中

类模板 :
    1) 成员变量和所有方法的定义
    2) 类变量的存储空间 
    3) 构造器方法
    4) 代码块
    5) 类名, 类所属的包, 类的父类

一旦被static修饰,意味着成员隶属于类, 只需要类就可以使用, 但是通过对象仍然也可以, 因为对象归属于类

什么时候使用static
当你希望一个成员归所有对象共享(方法的调用与调用者无关)时，就可以声明这个成员是static的

特点：
随着类的加载而加载
优先于对象存在
修饰的成员可以被对象共享
类名.static方法/属性就可以调用(本类中不需要加类名)
非静态环境下可以访问静态方法/成员
在静态环境下this,super被禁止，也不能直接访问非静态成员

单例模式

单例:在程序运行期间只允许有一个对象

两种模式：

饿汉式：
1.私有化构造器，防止外部随意创建对象
2.在类内部创建对象(类内部声明私有的静态的引用变量，并创建唯一的对象，将地址写入该引用)
3.给外界提供一个获取对象的公共方法

懒汉式:
1.私有化构造器，防止外部随意创建对象
2.类内部声明一个静态的私有的引用变量，但是此时不创建对象
3.给外界提供一个获取对象的公共方法，在该方法内部对引用变量中的值进行判断，若为null，创建对象，否则不创建对象

懒汉式，存在线程安全问题

代码块

static修饰的代码块—->静态代码块
在类被载入时，静态代码块会执行，且执行一次，由JVM自动执行
允许有多个代码块，这几个代码块之间顺序执行
可以利用静态代码块给静态成员赋值

没有被static修饰的代码块，动态代码块
在对象创建时，无条件执行一次，优先于构造器执行，可以利用动态代码块给空final量赋值

final

final关键字
可以修饰类, 方法, 属性, 变量
修饰类表明这个类是终结类(完美类), 不允许被扩展(不允许被继承)
修饰方法 表明这个方法是最终方法, 不允许被子类扩展(不允许被重写)
修饰变量 表明这个量是final量, 只允许赋值一次, 再不允许赋值了.

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

final修饰的变量字母全部大写

public staic final 全局常量

抽象类

抽象类：对现实世界一种类型的多种事物的统一抽象描述
具体类：对现实世界一种事物的抽象描述

抽象类：属性
构造器
具体方法
抽象方法(比具体类多了一个抽象方法)
特点：
1.用abstract修饰
2.抽象类不能被实例化
3.抽象方法必须在抽象类中，只有方法签名没有方法体。
4.不能用abstract修饰属性，私有方法，构造器，静态方法，final方法
抽象类体现的是模板设计，专门用来被继承

接口

接口:现实世界不同类型事物的共同行为特征
关注的是方法
用interface修饰

特点：1.接口中的所有属性均视为静态常量
2.接口中只允许有抽象方法
3.没有构造器
4.多继承机制，可以实现多个接口
5.实现接口必须对接口中的所有方法进行实现，否则为抽象类
6.一个类可以同时继承父类并实现接口
7.接口和类完全不同，接口之间可以相互继承
接口体现的是规范/标准

接口应用：
代理模式
为其他类提供一种代理以控制对这个对象的方法
将实现与管理分开
客户只需要关心接口，而不用了解细节，代理模式将具体实现封装起来

工厂模式
    面向接口编程，将具体实现封装起来，屏蔽细节
    体现了软编码的思想，将对象创建延迟到程序执行，这样在编译时就不必具备类
    将编译与运行分开

内部类

内部类：定义一个类的内部，相当于外部类的成员

内部类，没有被static修饰，与对象相关
嵌套类，被static修饰，与类相关，与外部类是平行关系

若外部类想要访问内部类的属性，必须创建内部类对象才能访问

内部类对象创建语法：
外部类类名.内部类类名 引用名 = 外部类对象.new内部类类名();

嵌套类对象创建语法:
外部类类名.内部类类名 引用名 = new 外部类类名.内部类类名();

匿名内部类：在new后面，用其隐含实现一个接口或者实现一个类
语法：new 父类构造器(实参列表) | 实现接口() {匿名内部类的类体部分}

/**
* 接口用于测试匿名内部类
* @author LENOVO
*
*/
public interface ITest {
public void test();
}

/**
* 利用匿名内部类:new 后边的就是匿名内部类
* 匿名内部类主要用于在创建对象的时候顺便实现接口，好直接可以创建对象
* @author LENOVO
*
*/
public class InnerTest {
public static void main(String[] args) {
ITest it = new ITest() {
@Override
public void test() {
System.out.println(“匿名内部类”);
}
};
System.out.println(it);
it.test();

    System.out.println(new Object() {
        @Override
        public String toString() {
            return "这是另一个匿名类";
        }
    });
}

}

枚举类

枚举类： 描述对象可数的类
enum关键字创建枚举类

注意：枚举类对象的属性不能允许被改动，用private final修饰
必须在枚举类第一行声明枚举类对象

枚举类的几个关键方法：
values()方法 返回枚举类型的对象数组(可以用于遍历所有枚举值)
valueof(String str) 把一个字符串转为对应的枚举类对象

特点：枚举中对象全是全局常量
不能创建枚举类对象，可以通过类名.对象调用
跟switch配合

Annotation

Annotation
可以当作修饰符一样使用，修饰包，类，构造器，方法，成员变量，参数，局部变量的声明

@Override 只能用方法覆盖
@Deprecated 过时的意思
@Suppress Warnings 抑制警告，这个注解还可以接收数据

注解：给运行时看注释性质内容，可以加在指定元素上

元注解
自定义注解