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.必须在第一行

• 1
• 2
• 3
• 4

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修饰,意味着成员隶属于类, 只需要类就可以使用, 但是通过对象仍然也可以, 因为对象归属于类

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17

什么时候使用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.接口和类完全不同，接口之间可以相互继承 
接口体现的是规范/标准

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

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

• 1
• 2
• 3
• 4
• 5

内部类

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

内部类，没有被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 "这是另一个匿名类";
        }
    });
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

}

枚举类

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

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

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

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

Annotation

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

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

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

元注解 
自定义注解