JavaSE复习总结(三)

我会带着你远行 2022-07-19 01:22 260阅读 0赞

## 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 抑制警告，这个注解还可以接收数据

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

元注解  
自定义注解