今天主要回顾一下 Java 面向对象的最后一部分的知识，算是对面向对象的一个总结了吧！
先来讲两个关键字吧！
1. abstract
如果一个类的所有子类都对这个类中的某个方法做了重写，那么这个时候这个类中的对应方法可以不定义方法体，需要用abstract修饰方法，从而成为一个抽象方法。抽象方法所在的类必须是抽象类。
抽象类不能创建对象。 --- 抽象方法一定是抽象类，但抽象类中不一定有抽象方法。
抽象类一定不是最终类，因为最终类不能被继承。
注意：任何一个类都有构造方法
抽象方法没有方法体，一定要被重写。
抽象方法可以定义被 static/final/private 修饰吗？ --- 不行
抽象方法中一定不能定义在最终类中。
如果一个类中的抽象方法用的是默认权限，对子类有什么要求？ --- 要求父子类要同包
package abstractx; public class AbstractDemo { //不允许被实例化 //Pet p = new Pet(); //p.eat(); //创建的是匿名内部类 Pet p = new Pet(){ @Override public void eat() { // TODO Auto-generated method stub } }; } //不想让这个类实例化，就定义一个抽象类 abstract class Animal{} //抽象类 abstract class Pet{ // public Pet(){} //抽象方法，因为长得像方法，但是没有方法体 public abstract void eat();/*{ //System.out.println("在吃东西~~~");//有没有方法体都不重要了 }*/ public void drink(){ System.out.println("在喝水中~~~"); } } //子类继承抽象类之后必须重写其中的抽象方法，除非子类也是抽象类 class Cat extends Pet{ @Override public void eat(){ System.out.println("这只猫在吃土~~~"); } } class Dog extends Pet{ @Override public void eat(){ System.out.println("这只狗在吃猫~~~"); } }
练习：定义一个类表示形状，提供获取周长和面积的方法，然后给这个类提供子类：矩形 - 正方形，椭圆 - 圆形
package abstractx; public class AbstractExer { public static void main(String[] args) { Shape f; f = new Rectangle(3,4); System.out.println(f.getGirth() + "," + f.getArea()); f = new Oval(4,5); System.out.println(f.getGirth() + "," + f.getArea()); } } abstract class Shape{ public abstract double getGirth(); public abstract double getArea(); } //代表矩形 class Rectangle extends Shape{ double width; double height; public Rectangle(double width, double height){ this.width = width; this.height = height; } @Override public double getGirth() { return 2 * (width + height); } @Override public double getArea() { // TODO Auto-generated method stub return width * height; } } //正方形 class Square extends Rectangle{ private double width; public Square(double width) { super(width, width); } } //椭圆形 class Oval extends Shape{ private double a; private double b; public static final double PI = 3.14; public Oval(double a, double b){ this.a = a; this.b = b; } @Override public double getGirth() { // TODO Auto-generated method stub return PI * a * b; } @Override public double getArea() { // TODO Auto-generated method stub return PI * (a + b); } } //圆形 class Circle extends Oval{ private double r; public Circle(double r){ super(r, r); } }
2. interface
（作用：作为模板或者是协议、约束等来使用）
接口中定义的都是抽象方法。类和接口之间用的是 implements 关键字来产生关联 --- 实现。类和实现接口之后需要重写接口中所有的抽象方法
接口不允许被实例化，也没有构造方法。
在 Java 中，支持的是类和接口之间的多实现 --- 一个类可以实现多个接口
在 Java 中，支持接口之间的多继承（接口可以继承接口），
在 JDK1.8 中，接口中允许定义实体方法 -- 这个是实体方法必须用 default 修饰
package cn.tedu.interfacex; import java.io.Serializable; public class InterfaceDemo { public static void main(String[] args) { System.out.println(Shape.girth); //Shape.girth = 1;//说明是使用final修饰的 //接口不允许实例化 //Shape s = new Shape(); } } interface Shape extends Cloneable,Serializable{ double girth = 0;//默认是用的 static，final //public Shape(){}不允许使用 //接口中的方法默认public abstract修饰 /*public abstract */double getGirth(); public abstract double getArea(); } //利用implements关键字让类和接口产生了联系 --- 实现 //Rectangle实现了 Shape接口 /*class Rectangle implements Shape, Cloneable{ } */ interface E{ void main(); } /*class B implements E{ void main() {//报错了，范围不一样 } }*/
关于接口的实现中，我们有：
package cn.tedu.interfacex; public class InterfaceDemo2 { public static void main(String[] args) { A a = new B1(); //在 Java 中支持的是类和类之间的单继承 //所以此时会形成一颗结构树 //所以比较容易的就能确定两个类之间是否有继承关系 //因此在进行强制转换的时候 //会检查要转换的对象的声明类和转换的类型是否有继承关系 //a对象的声明类型是 A 类，要转换的类型是B1 //B1继承了A，所以在编译时期就不报错 //到了运行的时候才会检查对象的实际类型和要转换的类型是否一致 //运行的时候，发现a的实际类型是 B1，要转换的类型是B1 //类型一致，允许转换 B1 b1 = (B1) a;//编译、运行都不会报错 //a对象的声明类型是 A 类，要转换的类型是B2 //B2继承了A,所以在编译时期就不报错 //到了运行的时候，a的实际类型是B1,要转换的类型是B2 //类型不一致，所以报错 --- ClassCastException /*B2 b2 = (B2) a;//编译通过，但是运行会报错 B2 b3 = (B2) b1;//编译直接不通过 C c = (C) a;*///编译直接不通过 //在 Java 中，类和接口之间是多实现，接口和接口之间是继承关系 //所以构成了一张图状结构 --- 网状结构， //不容易确定两个节点之间的关系 //因此在编译时期为了提高效率放弃检查 //直到运行时候在确定类型是否是否相同 D d = (D) a;//编译通过，但是运行报错 } } class A{} class B1 extends A{} class B2 extends A{} class C{} interface D{}
接着我们谈谈关于内部类方面的知识吧！！
内部类
1. 方法内部类
定义在方法中的类 --- 方法/局部内部类 --- 为了重复使用某段逻辑，并且使这段逻辑只从属于某一个方法使用
package cn.tedu.innerclass; public class InnerDemo1 { public static void main(String[] args) { Outer1 outer1 = new Outer1(); outer1.m(); } } class Outer1{ int i = 10; public void m(){ System.out.println("Outer~~~"); //当方法内部类使用所在的方法中的数据的时候， //要求这个属性的是一个常量 //从JDK1.8开始，方法内部类使用到当前方法中的数据的时候，将该数据默认为常量，不能改变 //常量的隐式声明： int j = 5; //方法内部类 //只能在定义它的方法中使用 //可以使用外部类中的属性何方法 //如果内部类和外部类存在同名属性或者方法，则使用内部类中定义 //只能用abstract/final修饰 //方法内部类可以定义非静态的属性和非静态方法 //但是不能定义静态变量和静态方法 //然而定义静态常量 class Inner1{//不能用static 修饰 int k = 8; static final int x = 7;//会报错,加final变成一个常量 public void m(){ System.out.println("Inner~~~"); i += 5; m2(); //外部类.this.外部类的方法或者属性 Outer1.this.m2(); System.out.println(j); //j++;//会报错 } public void m2(){ System.out.println("Inner m2~~~"); } } Inner1 i1 = new Inner1(); i1.m(); } public void m2(){ System.out.println("m2~~~"); } }
2. 成员内部类
Outer2.Inner2 oi2 = new Outer2().new Inner2();
package cn.tedu.innerclass; public class InnerDemo2 { public static void main(String[] args) { Outer2 o2 = new Outer2(); Outer2.Inner2 oi2 = new Outer2().new Inner2();//利用外部类对象创建内部类 System.out.println(oi2.j); } } class Outer2{ int i = 3; Inner2 i2 = new Inner2(); //成员内部类 //可以使用外部类中的属性和方法 //可以定义非静态属性和非静态方法 //但是不能定义静态属性和静态方法 //然而定义静态常量 class Inner2{//修饰不受什么限制 int j = 10; static final int k = 8;//也是要加final public void m(){ i += 3; Outer2.this.m();//调用外部类中的，不然就是递归了 } } public void m(){ System.out.println("Outer~~~"); } }
3. 静态内部类
用 static 修饰的类
Outer3.Inner3 oi3 = new Outer3.Inner3();
package cn.tedu.innerclass; public class InnerDemo3 { public static void main(String[] args) { Outer3.Inner3 oi3 = new Outer3.Inner3(); oi3.m(); } } class Outer3{ int i = 0; //静态内部类 //只能使用外部类中的静态属性和静态方法 //静态内部类中可以定义一切的方法和属性，无论静态还是非静态 static class Inner3{ int j = 8; static int k = 4; public void m(){ //System.out.println(i);//报错 } } }
4. 匿名内部类
匿名内部类本质上是实现了对应的接口或者是继承了对应的类
任何一个接口都可以存内在匿名内部类形式
一个类只要可以被继承，那么就可以存在匿名内部类形式 --- 最终类不存在匿名内部类的形式
package cn.tedu.innerclass; public class InnerDeom4 { public static void main(String[] args) { //匿名内部类 //a是匿名内部类产生的对象 //匿名内部类实际上是实现了对应的接口 A a = new A(){ @Override public void m() { System.out.println("running"); } }; a.m(); //匿名内部类实际上是继承了对应的类 B b = new B(){ @Override public void m() { System.out.println("running"); }}; b.m(); //C c = new C(){}; } } interface A{ void m(); } abstract class B{ public abstract void m(); } final class C{}
扩展：类中可以定义类，类中也可以定义接口，接口中也可以定义类，接口中也可以定义接口 --- 如果类中定义了接口或者式接口中定义了接口，那么称之为内部接口 --- 类中定义的接口，以及接口中定义的类和接口默认都是静态的。
谈到这儿，还有个 Lambda 表达式的内容：
package cn.tedu.innerclass; public class LambdaDemo { public static void main(String[] args) { //接口中只定义了1个抽象方法 //可以利用 /*Calc c = new Calc(){ @Override public double add(double i, double j) { // TODO Auto-generated method stub return i + j; }};*/ //表示重写Calc中的唯一的一个抽象方法add //Lambda表达式只能作用在函数式接口上 //方法体只有一句，可以省略{}和return 不写 //唯一的依据方法体的计算结果默认为当前方法的返回值 //Calc c = (double i, double j) -> i + j; //重写的是 Calc 接口中的方法add //add方法的参数列表的类型是已知的 //可以省略参数类型不写 //函数式编程 Calc c = (x, y) -> x + y; System.out.println(c.add(4.3, 2.5)); } } interface Calc{ double add(double i, double j); }
接着，前面打一个小结，接下来进行包的介绍：
包
声明包用的是 package --- 区分同名类，进行功能的划分
导入包用的是 import --- 导包的作用是用于提示代码从哪儿去找这个类（比如，我们前段时间经常使用的 Scanner、Arrays）
这个类
* 表示导入当前包下的所有的类但是不包括子包下的类
java --- 原生包，提供的一些常用的包，sun 公司自己用的
javax --- 扩展包，后阶段用的比较多
org --- 第三方厂商提供的一些常用的包，sun公司感觉比较好就收过来了
java.lang - 核心/基本包（ System String） ，包含了 Java 程序运行需要的基本类，在 Java 程序启动的时候，包下的类就已经自动加载到内存中，所以使用的时候可以不用导包
java.awt
java.applet --- JDK 1.9 后大部分类已经被抛弃了
java.util - 工具包
java.math --- 数学运算
java.io ---数据传输
java.net --- 网络通信，后面介绍
java.nio --- 高并发，服务器有关的包，双十一的时候抢购处理这些数据
java.text --- 格式化，超市去买东西，结账系统，8.88，* 3 * 0.88 出现 4 位小数，现实生活中是两位，就用这个包
总结：java.lang 包下的类以及同包类在使用的时候可以不用导包
包就是一个用来声明和导入的，现阶段还没有什么更多的知识介绍，以后遇到了，再介绍吧！！接下来谈谈垃圾分代回收方面的知识：
垃圾分代回收机制
（针对的是堆内存。）
java 中的每种数据类型大小都是确定的，所以所有的内存是由 Java 自己进行分配，意味着内存的管理和回收也是由 JVM 自己进行 --- 在 Java 中一旦产生内存问题导致程序员无法处理。（在 C 和 C++ 中就是自己来定义管理的）理论上在正常情况下 Java 中的堆内存是足够使用的 --- 当堆内存使用的负荷量（堆内存的 70 %，可能有的时候又不一样）超过一定限度的时候，会启动垃圾回收器（Garbage Collector --- GC）进行堆内存的回收释放 ---
C int 只要不超过 4 个字节就行。
int i = 3; --- 3
int j = i; --- 1
扩展：eden:from :to = 8:1:1
上图的简介：对象刚创建的时候是先放入新生代中的伊甸园区；如果在伊甸园区经过一次回收依然存在，那么将这个对象挪到幸存区，在幸存区中经过多次回收这个对象依然存在则挪到老生代。在回收的时候先回收新生代，如果新生代回收之后的内存足够使用则不扫描老生代。老生代的扫描频率要低于新生代
发生在新生代的回收 --- 初代回收 minor gc
发生在老生代的回收 --- 完全回收 full gc
（对于双十一，购物完之后就产生和销毁，应该将新生代设置得大一点，方便对象的创建）
扩展：对象创建完成之后会先试图放入新生代；如果新生代经过回收之后也放不开，则直接试图将该对象放入老生代。老生代如果也放不开，则会出现错误 --- OutOfMemoryError.