JavaSE学习之--抽象类,接口,内部类
"没有眼泪我们就会迷路，彻底变成石头，我们的心会变成冰凌，吻会变成冰块。"
作者：Mylvzi
文章主要内容：JavaSE学习之--抽象类，接口，内部类
目录
一.抽象类
1.抽象类的定义
2.抽象类的语法规则--abstract关键字
3.抽象类的注意事项
1.抽象类无法实例化对象
2.抽象类中可以存在普通成员变量，普通成员方法
3.抽象方法不能被private修饰
4.抽象方法不能被final和static修饰
5.抽象类必须被继承，且子类必须重写抽象类所有的抽象方法（可以快捷键创建）
6.抽象类可以存在构造方法，供子类初始化父类的成员变量（抽象类自己无法初始化）
7.抽象类中不一定含有抽象方法，但抽象方法存在的类一定是抽象类！！！
二.接口(interface)
1.接口的定义
2.接口的语法
1.接口关键字--》interface(替换原来的class),接口名一般以I开头（规范性）
2.关于接口方法
3.接口的实现--implements关键字
3.接口的特性
1.接口类型是一种引用类型，但是不能直接new接口对象（类似于抽象类）
2.接口的方法默认都是被public abstract修饰的，使用其他修饰符会报错
3.接口中的方法都不带有主体，只能有实现接口的类来实现
4.重写接口的抽象方法时，不能使用默认权限，只能是public修饰
5.接口中可以有变量，但变量都是被public static final修饰的
6.接口中不能有构造方法和代码块
7.接口编译完成的字节码文件的后缀格式也是.class
8.在jdk8中：接口还可以包含default方法
4.实现多接口
5.接口之间的继承
6.抽象类和接口的区别：
三. Object类
1.Object可以接受任意类型的对象
2.Object本质上还是Java中的一个类，含有一些自带的方法
1.toString方法--获取对象信息
toString的源码
2.equals方法--进行对象比较
equals的源码：
重写equals方法 ：
3.hashCode方法
hashCode的源码：
重写hashCode方法：
四. 接口使用实例
1.Comparable接口和Comparator接口
2.Clonable 接口和深拷贝
五.补充：内部类，外部类
1.内部类：
2.分类：
1.实例内部类
2.静态内部类
3.匿名内部类（通过接口实现）
4.局部内部类
补充：
一.抽象类
1.抽象类的定义
我们知道，对象是通过类来描绘的。但并不是所有的类都用来描绘对象，当你抽象出来的类所含有的信息不足以描绘出一个完整的对象时，这个类就叫做“抽象类”（所有的实现细节需要子类来自己完成）
我们发现shape中draw方法无法被具体实现，需要在对应的子类中实现，我们把这种方法叫做“抽象方法”，抽象方法就是所有子类方法的“蓝图”,根据这个蓝图来创建不同的子类特有的方法！同时，含有抽象方法的类就是抽象类！
2.抽象类的语法规则--abstract关键字
抽象类往往是父类，子类继承抽象类实现子类特有的方法，创建抽象类是通过关键字abstract
// abstract关键字创建抽象类
abstract class Shape {
// 创建抽象方法 不需要具体执行过程 是一个蓝图
public abstract void draw();
}3.抽象类的注意事项
1.抽象类无法实例化对象
抽象类包含的信息无法描绘一个完整的对象，所以无法通过抽象类来实例化对象！
Shape shape = new Shape();
2.抽象类中可以存在普通成员变量，普通成员方法
abstract class Shape {
// 普通成员变量
int a;
// 普通方法
public void method() {
System.out.println("普通方法！");
}
// 抽象方法--》不能含有函数体
abstract void method2();
}
class Rect extends Shape {
@Override
public void method() {
System.out.println("普通方法！");
}
@Override
void method2() {
System.out.println("抽象方法！");
}
}3.抽象方法不能被private修饰
如果一个方法被private修饰，那他只能在此类中使用，也就是只能在抽象类中使用，而抽象类的方法就是用来被子类重写的，所以抽象类方法不能被private修饰
4.抽象方法不能被final和static修饰
如果一个方法被final修饰，则该方法无法被重写；如果被static修饰，那么此方法是属于类的，无法被重写 （要谨记，重写是子类对父类方法的重写，被static修饰的方法无法被继承或重写）
5.抽象类必须被继承，且子类必须重写抽象类所有的抽象方法（可以快捷键创建）
abstract class Shape {
public abstract void draw();
public abstract void trangle();
}
class Rect extends Shape {
// 抽象方法必须被重写
@Override
public void draw() {
System.out.println("矩形");
}
@Override
public void trangle() {
}
}
class Flower extends Shape {
// trangle方法未被重写
// 只重写一个抽象方法-->err
// 所有的抽象方法必须被重写！
@Override
public void draw() {
System.out.println("✿");
}
}
注意到，这个报错的前一句是“Flower不是抽象的”，那是不是说明子类的也可以是抽象类呢？答案是可以的，Java中允许抽象子类，抽象子类将继续把抽象方法传递给他的子类，让他的子类来重写该抽象方法，形成了类的层级结构（但是不推荐将子类设置为抽象类，因为要重写多个方法）
abstract class Shape {
public abstract void draw();
public abstract void trangle();
}
abstract class Flower extends Shape {
// 只重写一个抽象方法-->err
// 所有的抽象方法必须被重写！
@Override
public void draw() {
System.out.println("✿");
}
}
class SmallFlower extends Flower {
// 父类Flower的抽象类
@Override
public void trangle() {
}
// shape的抽象类
@Override
public void draw() {
draw();
}
}6.抽象类可以存在构造方法，供子类初始化父类的成员变量（抽象类自己无法初始化）
abstract class Shape {
// 父类的成员变量
int a;
// 父类的构造方法
public Shape(int a) {
this.a = a;
}
// 抽象方法--》不能含有函数体
abstract void method2();
}
class Rect extends Shape {
int b;
public Rect(int a,int b) {
super(a);
this.b = b
}
@Override
void method2() {
System.out.println(a);
}
}7.抽象类中不一定含有抽象方法，但抽象方法存在的类一定是抽象类！！！
抽象类存在的意义是什么？多一层编译检查！！！
抽象类中抽象方法的存在强制了子类必须重写抽象方法，如果你想让所有的子类都包含某种方法，但具体的行为还要取决于具体的子类，就可以在抽象类（父类）中将此方法设置为抽象方法！
普通类的方法可以被继承，重写，但普通类的方法是具体实现的，有可能通过子类误调用成父类的方法，而抽象类的抽象方法不是具体实现的，他是一个“模板”，不含有函数体，所有的子类都可以根据自身情况去重写该方法，且不会出现误调用的情况！
二.接口(interface)
1.接口的定义
接口常见于我们的生活之中，比如最经典的是一直被诟病的苹果接口，众所周知，苹果接口只能给苹果手机充电，适用范围仅限于苹果设备，无法通过type-c接口充电，也就是说只有符合苹果规范的设备才能使用苹果接口！苹果接口是所有苹果设备的“共同规范”！
计算机中的接口也是类似的，是一种“共同规范”，简而言之类似于“父类”，所有能使用此接口的类都符合接口设定的规范（也就是类含有接口中的方法！！！）
2.接口的语法
// 将class替换为interface
public interface IShape {
// 接口中的所有方法都默认是public abstract的
public abstract void method1();
void method2();
// 接口中的成员变量都是默认被public static final修饰的
}1.接口关键字--》interface(替换原来的class),接口名一般以I开头（规范性）
2.关于接口方法
接口中的所有方法都默认是public abstract的，为了代码的规范性和简洁性，推荐第二种写法（method2）
3.接口的实现--implements关键字
我们创建了接口，接下来就要使用接口，相当于你把苹果手机插入到苹果接口，接下来就要使用苹果手机了；在Java中，我们称之为类实现接口
接口的实现是通过关键字--implements
public interface IShape {
void drawMap();
}
// implements关键字代表此类实现该接口
class Rect implements IShape {
@Override
public void drawMap() {
System.out.println("矩形！！！");
}
}
class Flower implements IShape {
@Override
public void drawMap() {
System.out.println("❀❀❀");
}
}
public class Testdemo {
// 类似于类里面的向上转型！！！
public static void drawMap2 (IShape ishape) {
ishape.drawMap();
}
public static void main(String[] args) {
drawMap2(new Rect());
drawMap2(new Flower());
}
}
注意事项：
1.子类与父类是继承关系，类与接口是实现关系，接口和父类很相似，很多用法都是类似的
2.接口中的方法都是抽象方法，实现接口的类必须重写接口中所有的方法！
3.接口中不能存在普通方法 ！！！
4.一个例子
代码实现：
// USB接口
public interface IUSB {
void openDevice();
void closeDevice();
}
// 鼠标类
public class Mouse implements IUSB {
// 实现USB接口就是重写USB接口中的所有方法
@Override
public void openDevice() {
System.out.println("鼠标设备开启！");
}
@Override
public void closeDevice() {
System.out.println("鼠标设备关闭！");
}
public void clickMouse() {
System.out.println("鼠标点击");
}
}
// 键盘类
public class KeyBoard implements IUSB {
// 实现USB类
@Override
public void openDevice() {
System.out.println("键盘设备开启！");
}
@Override
public void closeDevice() {
System.out.println("键盘设备关闭！");
}
public void inKeyBoard() {
System.out.println("键盘输入！");
}
}
// 计算机开机--通过usb使用相关设备--关机
public class Computer {
public void openComputer() {
System.out.println("电脑开启！");
}
public void closeComputer() {
System.out.println("电脑关闭！");
}
// 使用usb设备（类似于向上转型）
public void useUSB(IUSB iusb) {
// 注意这里开启，关闭设备是Mouse和KeyBoard类共有的，写在外面即可
iusb.openDevice();
// 利用关键字instanceof来判断引用的是哪个类
if (iusb instanceof Mouse) {
((Mouse) iusb).clickMouse();
//clickMouse是Mouse特有的方法，无法直接通过iusb实现
/* Mouse mouse = (Mouse) iusb;
mouse.clickMouse();*/
}else if(iusb instanceof KeyBoard) {
((KeyBoard) iusb).inKeyBoard();
}
iusb.closeDevice();
}
}
// 测试类
public class Testdemo3 {
public static void main(String[] args) {
Computer computer = new Computer();
computer.openComputer();
// 设备使用
computer.useUSB(new Mouse());
computer.useUSB(new KeyBoard());
computer.closeComputer();
}
}
3.接口的特性
1.接口类型是一种引用类型，但是不能直接new接口对象（类似于抽象类）
interface IUSB {
}
public class Test1 {
public static void main(String[] args) {
IUSB iusb = new IUSB();
// err
}
2.接口的方法默认都是被public abstract修饰的，使用其他修饰符会报错
interface IUSB {
void method1();
public abstract void method2();
private void method3();
}
3.接口中的方法都不带有主体，只能有实现接口的类来实现
interface IUSB {
void method1() {
System.out.println("hehe");
}
}
4.重写接口的抽象方法时，不能使用默认权限，只能是public修饰
接口中的方法默认都是public权限的，实现接口的类中重写的方法的权限不能比Public低，所以只能是Public修饰的
interface IUSB {
// 默认是public abstract
void method();
}
class Mouse implements IUSB {
@Override
// err
// 接口中的方法都是public权限
void method() {
System.out.println("hehe");
}
}
5.接口中可以有变量，但变量都是被public static final修饰的
static:说明变量是属于类的，能直接通过类来访问
final:证明变量无法被修改
interface IUSB {
int a = 10;
}
public static void main(String[] args) {
System.out.println(IUSB.a);// 可以直接通过接口访问-->被static修饰
IUSB.a = 20;// err无法被修改
}
6.接口中不能有构造方法和代码块
public interface INTERFACE {
// err
{
}
// err
static {
}
}7.接口编译完成的字节码文件的后缀格式也是.class
8.在jdk8中：接口还可以包含default方法
我们知道接口中的方法都是抽象方法，不含有主体，但在jdk8中引入了一个新特性-->default关键字，在接口中，如果方法被default修饰，则此方法可以含有主体，且在类中不必须被重写（相当于自动继承了）
interface IUSB {
void method1();
default void method2() {
System.out.println("This is a default method!");
}
}
class Mouse implements IUSB {
@Override
public void method1() {
System.out.println("hehe");
}
// method2不重写也不会报错
// 相当于“自动继承”
}
public class Test1 {
public static void main(String[] args) {
Mouse mouse = new Mouse();
mouse.method1();
// 没有重写method2，也能调用该方法，证明该方法被“自动继承”了
mouse.method2();
}
}
4.实现多接口
Java中类是单继承的，一个类无法继承多个类（不能有多个父亲），但可以同时实现多个接口！
通过implements+','实现多个接口！！！
下面通过类来表示一组动物
class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
}另外提供一些接口，分别表示 "会飞的", "会跑的", "会游泳的".
interface IFlying {
void fly();
}
interface ISwimming {
void swim();
}
interface IRunning {
void run();
}猫类：跑
// 猫类
class Cat extends Animal implements IRunning {
public Cat(String name) {
super(name);
}
// ctrl+i快速调出接口抽象方法的重写
@Override
public void run() {
System.out.println(this.name + "猫正在跑步");
}
}狗类：跑，游
// 狗类 跑+游
class Dog extends Animal implements IRunning,ISwimming {
public Dog(String name) {
super(name);
}
@Override
public void swim() {
System.out.println(this.name + "正在狗刨");
}
@Override
public void run() {
System.out.println(this.name + "狗正在跑步");
}
}
鸭子类：跑，游，飞
// 鸭子类 跑，飞，游
class Duck extends Animal implements IRunning,ISwimming,IFlying {
public Duck(String name) {
super(name);
}
@Override
public void fly() {
System.out.println(this.name + "鸭子正在飞");
}
@Override
public void swim() {
System.out.println(this.name + "鸭子正在游泳");
}
@Override
public void run() {
System.out.println(this.name + "鸭子正在跑步");
}
}注意：一个类实现多个接口时，所有接口中的抽象方法都要被重写！！！
public class Test1 {
public static void main(String[] args) {
Dog dog = new Dog("mimi");
dog.run();
dog.swim();
System.out.println("================");
Cat cat = new Cat("jiji");
cat.run();
System.out.println("================");
Duck duck = new Duck("hehe");
duck.fly();
duck.run();
duck.swim();
}
}
上面代码展示了Java面向对象编程中最常见的用法：一个类继承一个父类，同时实现多个接口！！
可以理解为接口时“部分共性”，但本质还是为了代码复用
继承表达式是is-a语义，接口表达的含义是“具有xxx特性”
- 猫是一种动物, 具有会跑的特性.
- 狗也是一种动物, 既能跑, 也能游泳
- 鸭子也是一种动物, 既能跑, 也能游, 还能飞
这样做的好处是可以让程序员忘记类型，只关注实现特性，关注某个类是否具有该特性
比如我们可以创建一个Robot类，他也可以实现IRunning接口，尽管他不是Animal类！
class Robot implements IRunning {
@Override
public void run() {
System.out.println("the robot is running!");
}
}创建一个方法调用接口中的方法（接口作为参数）
public class Test1 {
// 接口和类一样，可以作为参数类型，当对象传递时发生动态绑定
// 谁实现了接口，谁就可以调用接口方法
public static void Run(IRunning running) {
running.run();
}
public static void main(String[] args) {
// 匿名对象的直接调用
Run(new Cat("jiji"));
Run(new Dog("mimi"));
Run(new Duck("hehe"));
Run(new Robot());
}
5.接口之间的继承
接口之间也存在继承关系，不同于类的是，一个接口可以继承多个接口
interface IRunning {
void run();
}
interface ISwimming {
void swim();
}
// 两栖的动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {
}
class Frog implements IAmphibious {
...
}
通过接口继承创建一个新的接口 IAmphibious 表示 "两栖的". 此时实现接口创建的 Frog 类, 就继续要实现 run 方 法, 也需要实现 swim 方法，同时继承两个接口！！！
6.抽象类和接口的区别：
1.成员变量：抽象类中可以含有普通成员变量，接口中的成员变量都是被public static final修饰的
2.方法：抽象类中既可以有抽象方法也可以有普通方法，而接口中所有的方法都是public abstract修饰
3.继承关系：一个类只能继承一个父类，但可以实现多个接口。但接口与接口之间只有继承关系
三. Object类
Object类是Java中默认提供的一个类，他是所有类的父类，是类的“祖先”。为什么会有这么一个类呢？其实也很好理解，Java是一个面向对象编程的语言，它存在很多自定义的类，那程序员是如何写出这些自定义的类呢？本质上还是通过Object这个祖先类来开发的！！！
1.Object可以接受任意类型的对象
class Person{};
class Stu{};
public class Test1 {
// 此处发生了向上转型
public static void func(Object object) {
System.out.println(object);
}
public static void main(String[] args) {
func(new Person());
func(new Stu());
}
}
2.Object本质上还是Java中的一个类，含有一些自带的方法
本文主要讲解equals,hashcode,toString方法
1.toString方法--获取对象信息
前面我们已经重写了很多toString方法，当时可能很不理解为什么toString方法要重写呢？他是来源于哪个类呢？现在可以解释这个问题了，toString方法是Object类自带的一个方法，所有的类都是Object的子类，所以要重写toString方法来实现我想获取的信息
toString的源码
2.equals方法--进行对象比较
在Java中，==比较时
如果左右两侧是基本数据类型（int等等），直接比较值的大小即可
如果左右两侧是引用数据类型（比如对象），实际上比较的是引用类型的地址是否相同
如果想比较对象中的内容，就要重写equals方法
equals的源码：
public static void main(String[] args) {
Person person1 = new Person();
Person person2 = new Person();
// 当两个引用类型比较时，实际上比较的是地址
System.out.println(10 == 20);// false
System.out.println(person1 == person2);// false
System.out.println(person1.equals(person2));// false
System.out.println("=======================");
person2 = person1;
System.out.println(person1.equals(person2));// true
}
两个对象的比较是判断对象的地址是否相同，也即是在内存中存储的位置是否相同
Person person1 = new Person("lisi",18);
Person person2 = new Person("lisi",18);
System.out.println(person1.toString());
System.out.println(person2.toString());可以看出，两个对象的地址不同
重写equals方法 ：
假如我想使用Person类中的age来判断两个对象是否相同，此时就要重写equals方法
class Person{
int age;
public Person(int age) {
this.age = age;
}
@Override
public boolean equals(Object object) {
// 两个对象地址相同，直接返回true
if (this == object) return true;
// 比较的对象是null或两个对象的类型不同，直接返回false
if (object == null || getClass() != object.getClass()) return false;
// 此处进行向下转型
Person person = (Person) object;
return age == person.age;
}
@Override
public int hashCode() {
return Objects.hash(age);
}
}
public class Test1 {
public static void main(String[] args) {
Person person1 = new Person(10);
Person person2 = new Person(20);
Person person3 = new Person(20);
System.out.println(person1.equals(person2));// false
System.out.println(person2.equals(person3));// true
}注意：可以通过快捷键快速生成toString和hashcode的重写方法
结论：通过对象中的内容进行比较时，一定要重写toString方法！
3.hashCode方法
对象的hashCode值反应的是其在内存中的存储位置
hashCode的源码：
注：native代表此方法是由c/c++写的，无法查看真正的源码
public static void main(String[] args) {
// 创建两个内容完全相同的person对象
Person person1 = new Person("lisi",18);
Person person2 = new Person("lisi",18);
// 验证他们在内存中是否位于同一地址
System.out.println(person1.hashCode());
System.out.println(person2.hashCode());
// 结果显示并不位于同一块地址
} 
重写hashCode方法：
同样的，我们也可以重写hashCode方法，实现只要内容完全相同，对象就处于内存中的同一块地址（快捷方法和toString一样）
// 重写hashCode方法
@Override
public int hashCode() {
return Objects.hash(name, age);
}
public static void main(String[] args) {
// 创建两个内容完全相同的person对象
Person person1 = new Person("lisi",18);
Person person2 = new Person("lisi",18);
// 验证他们在内存中是否位于同一地址
System.out.println(person1.hashCode());
System.out.println(person2.hashCode());
} 
结论：
1、hashCode方法用来确定对象在内存中存储的位置是否相同
2、事实上hashCode() 在散列表中才有用，在其它情况下没用。在散列表中hashCode() 的作用是获取对象的 散列码，进而确定该对象在散列表中的位置。
总结：
如果是自定义类型，记得一定要重写equals和hashCode方法，因为你的逻辑不是根据地址来判断类型是否相同，而是根据类型的属性来判断，所以要重写这两个方法
四. 接口使用实例
1.Comparable接口和Comparator接口
先设定一个学生对象，并创建一个学生数组
class Student {
String name;
int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
}
public class Test2 {
public static void main(String[] args) {
Student[] students = new Student[] {
new Student("张三", 10),
new Student("李四", 20),
new Student("王五", 30),
new Student("赵六", 40),
};
}
}假如我们现在想通过年龄进行排序，能否直接利用Arrays.sort呢？
Arrays.sort(students);// 可以直接这样排序吗？
发现产生类型转换异常，原因在于之前使用Arrays.sort排序的数组是整形，可以直接通过比较数字的大小来进行排序的，而student是一个引用类型，无法直接进行排序，必须指定排序的依据，比如我现在想通过年龄进行排序，该怎么实现呢？通过Comparable接口！！！
class Student implements Comparable{
String name;
int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
// 重写compareTo
public int compareTo(Object o) {
Student s = (Student) o;
/* if (this.age > s.age) {
return 1;
} else if (this.age == s.age) {
return 0;
}else {
return -1;
}*/
return this.age-s.age;
}
}
// 输出打印
Arrays.sort(students);
System.out.println(Arrays.toString(students)); 
sort方法会自动调用compareTo方法，compareTo方法的参数是Object类型，要进行强制类型转换。通过重写Comparable接口中的compareTo方法实现根据类的属性进行比较的目的
如果数据类型是数字可以直接调用sort方法，如果数组的数据类型是对象，则要使每个对象具有“可比较性”，就是要让对应的类实现Comparable接口，并重写compareTo方法 ，你需要告诉编译器是通过类的哪项属性进行比较的
但是我们发现这个方法也有一定的缺陷型，缺陷型在于我们重写compareTo方法时只能指定类的一个属性进行比较，比如在上述代码中的compareTo方法中，我们是通过age这个属性来比较的，但如果我们想通过名字比较呢？那不是要重写compareTo方法吗？可以看出，这样进行比较的方法可拓展性太差，对类的侵入性强，那有没有一种方法可以实现想通过什么比较就通过什么比较呢？答案是有的，即通过“比较器”来进行比较
使用方法：构造一个比较类，实现Comparator接口，重写compare方法
class Student{
String name;
int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
// 表示比较的是Student对象（最好加上，在重写方法时会很方便）
class AgeComparator implements Comparator {
@Override
public int compare(Student o1, Student o2) {
return o1.age- o2.age;
}
}
class NameComparator implements Comparator {
@Override
public int compare(Student o1, Student o2) {
return o1.name.compareTo(o2.name);
}
}
public class Test2 {
public static void main(String[] args) {
Student student1 = new Student("zhangsan",10);
Student student2 = new Student("lisi",15);
AgeComparator ageComparator = new AgeComparator();
System.out.println(ageComparator.compare(student1, student2));
NameComparator nameComparator = new NameComparator();
System.out.println(nameComparator.compare(student1,student2));
} 
解释一下：“return o1.name.compareTo(o2.name);”为什么通过name能直接调用compareTo方法？
因为name是一个字符串类型，属于String类，而String类中有compareTo方法！！！
注意：Comparator和Comparable是两个不同的接口，且用法也不同
Comparator是为了构造比较器
Comparable是使类具有可比较性
为了进一步加深对接口的理解, 我们可以尝试自己实现一个 sort 方法来完成刚才的排序过程(使用冒泡排序
// 能够排序的数组，要求数组元素必须具有可比较性，那把每个类型都设置为Comparable就能实现可比较性
public static void bubble_sort(Comparable[] comparables) {
for (int i = 0; i < comparables.length-1; i++) {
for (int j = 0; j < comparables.length-1-i ; j++) {
if(comparables[j].compareTo(comparables[j+1]) > 0) {
// 不符合顺序就交换位置
Comparable tmp = comparables[j];
comparables[j] = comparables[j+1];
comparables[j+1] = tmp;
}
}
}
}2.Clonable 接口和深拷贝
Java中内置了很多有用的方法，clone就是其一，clone方法是Object类内置的一个方法，clone方法能够实现对象的拷贝，但要合法使用clone方法，需要先实现Clonable接口，否则会报错
原型：
代码实现：
class Money implements Cloneable {
public double money = 19.9;
}
// 要想能clone,必须先实现Clonable接口
class Stu implements Cloneable{
int age;
Money m;
public Stu(int age) {
this.age = age;
m = new Money();
}
// 重写Object类中的clone方法
// 访问权限是protected,只能跨包子类中使用
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
public class Testdemo1 {
public static void main(String[] args) throws CloneNotSupportedException {
Stu stu1 = new Stu(18);
// 返回值是Object，所以必须进行强制类型转换
Stu stu2 = (Stu) stu1.clone();
System.out.println(stu1.m.money);// 19.9
System.out.println(stu2.m.money);// 19.9
System.out.println("================");
}
}注意：main后面必须添加：
throws CloneNotSupportedException
否则会报错
鼠标移动到clone,同时按下：alt+enter,点击第一行即可自动添加
现在我改变Stu2的m对象的money,再分别打印，看看会有什么结果
// 返回值是Object，所以必须进行强制类型转换
Stu stu2 = (Stu) stu1.clone();
System.out.println(stu1.m.money);// 19.9
System.out.println(stu2.m.money);// 19.9
System.out.println("================");
stu2.m.money = 20;
System.out.println(stu1.m.money);
System.out.println(stu2.m.money);
可以发现不仅Stu2的Money改变了，Stu1的Money也改变了，可我们不是只改变了Stu2的money吗？原因在于Cloneable的拷贝是一种浅拷贝，所谓浅拷贝就是只拷贝当前对象（Stu），并不拷贝对象里面的对象（m） ，让我画图解释一下
有浅拷贝就有深拷贝，深拷贝就是为了解决浅拷贝的缺陷存在的
深拷贝：解决对象里面嵌套对象的拷贝
拷贝方法：先克隆大对象，再克隆小对象（先暂存大对象）
修改后的Stu类
// 要想能clone,必须先实现Clonable接口
class Stu implements Cloneable{
int age;
Money m;
public Stu(int age) {
this.age = age;
m = new Money();
}
// 重写Object类中的clone方法
// 访问权限是protected,只能跨包子类中使用
@Override
protected Object clone() throws CloneNotSupportedException {
// 深拷贝：先克隆大对象，再克隆小对象
Stu tmp = (Stu)super.clone();
// 克隆小对象
// 要克隆的是当前对象的里面的m对象，所以通过this表示当前对象调用
// 将当前对象的m克隆到tmp的m之内，所以两边要对齐
tmp.m = (Money)this.m.clone();
return tmp;
}
}运行截图：
深拷贝 浅拷贝看的是代码的实现过程，浅拷贝并不实现对象内的对象的拷贝，深拷贝实现对象内的对象的拷贝
注意：能被拷贝的对象一定要实现clone接口！！！
五.补充：内部类，外部类
1.内部类：
定义在类里面或方法内部的类就叫做内部类
2.分类：
说内部类时一定要说清楚是什么内部类，对于内部类来说重点掌握静态内部类和匿名内部类
1.实例内部类
在类中定义的不被static修饰的类就叫做实例内部类
class OuterClass {
int data1 = 1;
int data2 = 2;
// 实例内部类
class InnerClass {
int data3 = 3;
int data4 = 4;
// 实例内部类中的成员变量不能被static修饰，但可以是static final修饰
// static int data5 = 5;
static final int data10 = 10;
public void method3() {
System.out.println(data3);
}
public void method4() {
// 访问外部类的成员变量，先实例化一个外部对象，通过外部对象访问成员变量
OuterClass outerClass = new OuterClass();
System.out.println(data4);
System.out.println(data1);// 打印内部类的data1
// System.out.println(data5);
System.out.println("=================");
System.out.println(OuterClass.this.data1);// 打印外部类的data1
System.out.println(outerClass.data2);
}
}
}
public static void main(String[] args) {
// 实例化一个实例内部类-->先实例化一个外部类对象，再实例化此外部类对象的内部类
// 实例内部类依赖于外部类对象
// 第一种写法（实例化出一个具体的外部类对象）
OuterClass outerClass = new OuterClass();
OuterClass.InnerClass innerClass = outerClass.new InnerClass();
// 第二种写法（用了一个匿名的外部类对象）
OuterClass.InnerClass innerClass2 = new OuterClass().new InnerClass();
// OuterClass.InnerClass innerClass = new OuterClass.InnerClass();// err
innerClass.method3();
innerClass.method4();
}
总结：
1.实例内部类依赖于外部类对象，必须先有外部类对象才能实例化内部类对象
2.实例化一个内部类对象的方法有两种
- 先实例化出一个具体的外部类对象，再实例化此外部类对象的内部类对象（注意语法格式）
- 利用匿名外部类对象实例化内部类对象（很快速，但无具体的外部类对象）
3.实例内部类中的成员变量不能被static修饰，因为被static修饰的变量不依赖于对象，在类加载时就创建，而实例内部类的实例化又依赖于对象，两者矛盾。但如果被final修饰，则编译通过（此时已经是常量了）
4.当外部类成员变量和内部类成员变量相同时，会默认打印内部类的成员变量，Outerclass.this.访问外部类的成员变量
2.静态内部类
在类中定义的被static修饰的类就叫做静态内部类
我们都知道，类的成员变量如果被static修饰，那就说明这个成员变量是“类变量”，不依赖于对象。同样的，对于静态内部类的获取不依赖于外部类对象！
class OuterClass {
int data1 = 1;
int data2 = 2;
// 静态内部类
static class InnerClass {
int data3 = 3;
int data4 = 4;
static int data5 = 5;
public void method3() {
System.out.println(data3);
}
public void method4() {
// 访问外部类的成员变量，先实例化一个外部对象，通过外部对象访问成员变量
OuterClass outerClass = new OuterClass();
System.out.println(data4);
System.out.println(data5);
System.out.println("=================");
System.out.println(outerClass.data1);
System.out.println(outerClass.data2);
}
}
}
public class Test1 {
public static void main(String[] args) {
// 如何实例化一个静态内部类对象呢？
// 一定是先有外部类，再有内部类,也就是说一定要指明内部类的归属
OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
innerClass.method3();
innerClass.method4();
}
}
总结：
1.静态内部类是定义在类内部的，被static修饰的类
2.实例化一个静态内部类：外部类名.内部类名--》一定是先有外部类，再有内部类,也就是说一定要指明内部类的归属
3.在内部类中想要访问外部类的成员变量--》先实例化一个外部类对象，通过外部类对象访问成员变量
3.匿名内部类（通过接口实现）
// 匿名内部类
interface A {
void methodA();
}
public class Test1 {
public static void main(String[] args) {
int a = 10;
a = 20;// err如果修改，在匿名内部类中就无法打印
final int b = 20;
new A(){// 以下代码相当于一个类实现了A接口，并重写了A的方法，但是这个类没有名称，所以叫做匿名内部类（）通过接口实现
@Override
public void methodA() {
// System.out.println(a);
System.out.println(b);
System.out.println("hehe!!!");
}
}.methodA();
}
}总结：
1.在匿名内部类中只能打印被final修饰数据（常量） 或只被初始化未被修改过的数据（如果修改，就无法访问），所以建议在匿名内部类中访问的数据都设置为final修饰的
2.匿名内部类是通过接口实现的，调用方法有两种
- 直接在花括号外.方法名
- 创建一个对象，通过对象调用
4.局部内部类
在方法中定义的类就是局部内部类
public class OutClass {
int a = 10;
public void method(){
int b = 10;
// 局部内部类：定义在方法体内部
// 不能被public、static等访问限定符修饰
class InnerClass{
public void methodInnerClass(){
System.out.println(a);
System.out.println(b);
}
}
// 只能在该方法体内部使用，其他位置都不能用
InnerClass innerClass = new InnerClass();
innerClass.methodInnerClass();
}
public static void main(String[] args) {
// OutClass.InnerClass innerClass = null; 编译失败
}
}总结：
1.局部内部类只能在定义的方法之中使用，子其他位置均无法使用
2.局部内部类非常少见，了解即可
补充：
一个类对应一个字节码文件
实例，静态内部类和匿名内部类的字节码文件名称不同，
实例，静态内部类的字节码文件名称：外部类名$内部类名
匿名内部类的字节码文件名称：外部类类名$数字
总结：
本文主要讲述了抽象类，接口的定义，使用，以及两者的区别。抽象类和接口都是面向对象编程的重要语法，要好好理解他们的作用和基础的语法，会大大提高代码的效率！最后还介绍了一种特殊的类--》内部类 ，重点掌握静态内部类和匿名内部类