文章目录
一、final关键字
final 表示不可改变的含义
采用 final 修饰的类不能被继承
采用 final 修饰的方法不能被覆盖
采用 final 修饰的变量不能被修改
final 修饰的变量必须显示初始化
如果修饰的引用，那么这个引用只能指向一个对象，也就是说这个引用不能再次赋值， 但被指向的对象是可以修改的
构造方法不能被 final 修饰
会影响 JAVA类的初始化:final 定义的静态常量调用时不会执行 java的类初始化方法， 也就是说不会执行 static 代码块等相关语句，这是由 java虚拟机规定的。我们不需要了解的很深，有个概念就可以了
二、抽象类
看我们以前示例中的 Person、Student 和 Employee，从我们使用的角度来看主要对 Student 和 Employee 进行实例化，Person 中主要包含了一些公共的属性和方法，而Person我们通常不会实例化，所以我们可以把它定义成抽象的：
在 java中采用 abstract 关键字定义的类就是抽象类，采用 abstract 关键字定义的方法就是抽象方法
抽象的方法只需在抽象类中，提供声明，不需要实现
如果一个类中含有抽象方法，那么这个类必须定义成抽象类
如果这个类是抽象的，那么这个类被子类继承，抽象方法必须被重写。如果在子类中不复写该抽象方法，那么必须将此类再次声明为抽象类
抽象的类是不能实例化的，就像现实世界中人其实是抽象的，张三、李四才是具体的
抽象类不能被 final 修饰 抽象方法不能被 final 修饰，因为抽象方法就是被子类实现的
三、接口
1、接口总结
接口我们可以看作是抽象类的一种特殊情况，在接口中只能定义抽象的方法和常量
1)在 java中接口采用 interface 声明
2) 接口中的方法默认都是 public abstract 的，不能更改
3) 接口中的变量默认都是 public static final 类型的，不能更改，所以必须显示的初始化
4) 接口不能被实例化，接口中没有构造函数的概念
5) 接口之间可以继承，但接口之间不能实现
6) 接口中的方法只能通过类来实现，通过implements关键字
7) 如果一个非抽象的类实现了接口，那么接口中所有的方法必须实现
8) 一类可以实现多个接口
9）extends和implements可以共存，extends在前，implements在后。
10）使用接口写代码时，可以使用多态
2、接口的进一步应用
在 java 中接口其实描述了类需要做的事情，类要遵循接口的定义来做事，使用接口到底有什么本质的好处？可以归纳为两点：
采用接口明确的声明了它所能提供的服务
解决了 Java单继承的问题
实现了可接插性（重要）
我们应尽量面向接口编程，不要面向抽象编程
四、接口和抽象类的区别
**a) 接口描述了方法的特征，不给出实现，一方面解决 java 的单继承问题，实现了强大的可接插性
b) 抽象类提供了部分实现，抽象类是不能实例化的，抽象类的存在主要是可以把公共的代码移植到抽象类中
c) 面向接口编程，而不要面向具体编程（面向抽象编程，而不要面向具体编程）
d) 优先选择接口（因为继承抽象类后，此类将无法再继承，所以会丧失此类的灵活性）
**
五、类之间的关系
1. 泛化关系，类和类之间的继承关系及接口与接口之间的继承关系
2. 实现关系，类对接口的实现
3. 关联关系，类与类之间的连接，一个类可以知道另一个类的属性和方法，在 java语言中使用成员变量体现
4. 聚合关系，是关联关系的一种，是较强的关联关系，是整体和部分的关系，如：汽车和轮胎，它与关联关系不同，关联关系的类处在同一个层次上，而聚合关系的类处在不平等的 层次上，一个代表整体，一个代表部分，在 java语言中使用实例变量体现
5.合成关系，是关系的一种，比聚合关系强的关联关系，如：人和四肢，整体对象决定部分 对象的生命周期，部分对象每一时刻只与一个对象发生合成关系，在 java语言中使用实例 变量体现
6. 依赖关系，依赖关系是比关联关系弱的关系，在java语言中体现为返回值，参数，局部变量和静态方法调用
六、Object类
a) Object 类是所有 Java类的根基类
b) 如果在类的声明中未使用extends 关键字指明其基类，则默认基类为Object 类
1、toString（）方法
返回该对象的字符串表示。通常toString 方法会返回一个“以文本方式表示”此对象的字
符串，Object 类的 toString 方法返回一个字符串，该字符串由类名加标记@和此对象哈希码 的无符号十六进制表示组成，Object 类 toString源代码如下：
getClass().getName() + ‘@’ + Integer.toHexString(hashCode())
在进行 String与其它类型数据的连接操作时，如： System.out.println(student);，它自动调用该对象的 toString()方法
2、finalize
垃圾回收器（Garbage Collection），也叫GC，垃圾回收器主要有以下特点：
当对象不再被程序使用时，垃圾回收器将会将其回收
垃圾回收是在后台运行的，我们无法命令垃圾回收器马上回收资源，但是我们可以告诉他，尽快回收资源（System.gc 和Runtime.getRuntime().gc()）
垃圾回收器在回收某个对象的时候，首先会调用该对象的 finalize 方法
GC主要针对堆内存
单例模式的缺点
当垃圾收集器将要收集某个垃圾对象时将会调用 finalize，建议不要使用此方法，因为此方法 的运行时间不确定，如果执行此方法出现错误，程序不会报告，仍然继续运行、
public class Finalize01
public static void main(String[] args) {
Person person = new Person();
person.id = 1000;
person.name = "张三";
//将 person设置为 null 表示，person不再执行堆中的对象
//那么此时堆中的对象就是垃圾对象
//垃圾收集（GC）就会收集此对象
//GC不会马上收集，收集时间不确定
//但是我们可以告诉GC，马上来收集垃圾，但也不确定，会马上来
//也许不会来 person = null;
//通知垃圾收集器，来收集垃圾 System.gc();
/* try {
Thread.sleep(5000);
}catch(Exception e) {
}
*/ }
}
class Person{
int id;
String name;
izeTest01 {
//此方法垃圾收集器会调用
public void finalize() throws Throwable {
System.out.println("Person.finalize()");
}
}
注意以下写法：
public class FinalizeTest02 {
public static void main(String[] args) {
method1();
}
private static void method1() {
Person person = new Person();
person.id = 1000;
person.name = "张三";
//这种写法没有多大的意义，
//执行完成方法，所有的局部变量的生命周期全部结束
//所以堆区中的对象就变成垃圾了（因为没有引用指向对象了）
//person = null;
}
}
class Person{
int id;
String name;
public void finalize() throws Throwable {
System.out.println("Person.finalize()");
}
}
3、==与equals方法
等号“==”
等号可以比较基本类型和引用类型，等号比较的是值，特别是比较引用类型，比较的是引用的内存地址
采用 equals 比较两个对象是否相等
需要注意的是在使用我们自己重写后的equals方法，需要使用instanceof确定两种类型是否为同一类型，同一类型才有可比性，不是同一类型，考虑向上或向下转型
七、包和 import
1、包
**包其实就是目录，特别是项目比较大，java文件特别多的情况下，我们应该分目录管理,在 java 中称为分包管理，
1、包名称通常采用小写
2、包的命名应该有规则，不能重复，一般采用公司网站逆序， 如：com.bjpowernode.项目名称.模块名称 com.bjpowernode.exam **
2、import
如何使用包下的 class文件？需要使用import关键字导入类
3、JDK常用开发包
java.lang，此包 Java语言标准包，使用此包中的内容无需 import 引入
java.sql，提供了 JDBC接口类
java.util，提供了常用工具类
java.io，提供了各种输入输出流
七、访问控制权限
java访问级别修饰符主要包括：private protected和 public，可以限定其他类对该类、属性和方法的使用权限，
注意以上对类的修饰只有：public 和 default，内部类除外
如果 class 不采用 public 修饰，那么此时的 class，只能被该包下的类访问，其他包下无法访问
八、内部类
在一个类的内部定义的类，称为内部类 ，内部类主要分类：
实例内部类
局部内部类
静态内部类
1、实例内部类
创建实例内部类，外部类的实例必须已经创建
实例内部类会持有外部类的引用
实例内部不能定义 static 成员，只能定义实例成员
public class InnerClassTest01 {
private int a;
private int b;
InnerClassTest01(int a, int b) {
this.a = a;
this.b = b;
}
//内部类可以使用 private 和 protected修饰
private class Inner1 {
int i1 = 0;
int i2 = 1;
int i3 = a;
int i4 = b;
//实例内部类不能采用static 声明
//static int i5 = 20;
}
public static void main(String[] args) {
InnerClassTest01.Inner1 inner1 = new InnerClassTest01(100, 200).new
Inner1();
System.out.println(inner1.i1);
System.out.println(inner1.i2);
System.out.println(inner1.i3);
System.out.println(inner1.i4);
}
}
2、静态内部类
静态内部类不会持有外部的类的引用，创建时可以不用创建外部类
静态内部类可以访问外部的静态变量，如果访问外部类的成员变量必须通过外部类的实例访问
【示例代码】
public class InnerClassTest02 {
static int a = 200;
int b = 300;
static class Inner2 {
//在静态内部类中可以定义实例变量
int i1 = 10;
int i2 = 20;
//可以定义静态变量 static int i3 = 100;
//可以直接使用外部类的静态变量
static int i4 = a;
//不能直接引用外部类的实例变量
//int i5 = b;
//采用外部类的引用可以取得成员变量的值
int i5 = new InnerClassTest02().b;
}
public static void main(String[] args) {
InnerClassTest02.Inner2 inner = new InnerClassTest02.Inner2();
System.out.println(inner.i1);
}
}
3、局部内部类
局部内部类是在方法中定义的，它只能在当前方法中使用。和局部变量的作用一样局部内部类和实例内部类一致，不能包含静态成员
public class InnerClassTest03 {
private int a = 100;
//局部变量，在内部类中使用必须采用 final 修饰
public void method1(final int temp) {
class Inner3 {
int i1 = 10;
//可以访问外部类的成员变量
int i2 = a;
int i3 = temp;
}
//使用内部类
Inner3 inner3 = new Inner3();
System.out.println(inner3.i1);
System.out.println(inner3.i3);
}
public static void main(String[] args) {
InnerClassTest03 innerClassTest03 = new InnerClassTest03();
innerClassTest03.method1(300);
}
}
4、匿名内部类
是一种特殊的内部类，该类没有名字
没有使用匿名类：
public class InnerClassTest04 {
public static void main(String[] args) {
MyInterface myInterface = new MyInterfaceImpl();
myInterface.add();
}
}
interface MyInterface {
public void add();
}
class MyInterfaceImpl implements MyInterface {
public void add() {
System.out.println("-------add------");
}
}
使用匿名类:
public class InnerClassTest05 {
public static void main(String[] args) {
/*
MyInterface myInterface = new MyInterface() {
public void add() {
System.out.println("-------add------");
}
};
myInterface.add();
*/
/*
MyInterface myInterface = new MyInterfaceImpl();
InnerClassTest05 innerClassTest05 = new InnerClassTest05();
innerClassTest05.method1(myInterface);
*/
InnerClassTest05 innerClassTest05 = new InnerClassTest05();
innerClassTest05.method1(new MyInterface() {
public void add() {
System.out.println("-------add------");
}
});
}
private void method1(MyInterface myInterface) {
myInterface.add();
}
}
interface MyInterface {
public void add();
}
/*
class MyInterfaceImpl implements MyInterface {
public void add() { System.out.println("-------add------");
} }
*/
总结
本章深入的学习了面向对象的知识，为之后的学习奠定了基础，之后主要就是面向接口编程，学习Java的常用类、常用方法。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
