目录
1.Clonable接口和深拷贝
Java 中内置了一些很有用的接口, Clonable 就是其中之一，Object 类中存在一个 clone 方法, 调用这个方法可以创建一个对象的 "拷贝". 但是要想合法调用 clone 方法, 必须要先实现 Clonable 接口, 否则就会抛出 CloneNotSupportedException 异常。
class Students implements Cloneable { public String name; public int age; @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); } public Students(String name, int age) { this.name = name; this.age = age; } @Override public String toString() { return "{" + "name=" + name + ", age=" + age + "}"; } }public class text { public static void main(String[] args) throws CloneNotSupportedException { Students student1=new Students("张三",10); Students student2=(Students) student1.clone();//强制类型转化 System.out.println(student1); System.out.println(student2); } }
class Money{
public double m=25.0;
}
class Students implements Cloneable {
public String name;
public int age;
public Money money=new Money();
@Override 浅拷贝
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
public Students(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "{" +
"name=" + name + " "+
", age=" + age +" "+
", money=" + money.m +
'}';
}
}
public class text {
public static void main(String[] args) throws CloneNotSupportedException {
Students student1=new Students("张三",10);
Students student2=(Students) student1.clone();
System.out.println(student1);
System.out.println(student2);
System.out.println("====");
student1.money.m=15.0;
System.out.println(student1);
System.out.println(student2);
}
}
通过clone，我们只是拷贝了Students对象，但是Students对象中的Money对象，并没有拷贝，通过student1这个引用修改了m的值后，student2这个引用访问m的时候，值也发生了改变。
class Money implements Cloneable{
public double m=25.0;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
class Students implements Cloneable {
public String name;
public int age;
public Money money=new Money();
@Override //深拷贝，将引用的对象（student1）中的对象也拷贝到目标对象中
protected Object clone() throws CloneNotSupportedException {
Students temp=(Students) super.clone();
temp.money=(Money)this.money.clone();
return temp;
}
public Students(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "{" +
"name=" + name + " "+
", age=" + age +" "+
", money=" + money.m +
'}';
}
}
public class text {
public static void main(String[] args) throws CloneNotSupportedException {
Students student1=new Students("张三",10);
Students student2=(Students) student1.clone();
System.out.println(student1);
System.out.println(student2);
System.out.println("====");
student1.money.m=15.0;
System.out.println(student1);
System.out.println(student2);
}
}
通过clone，我们拷贝Students对象，同时将Students对象中的Money对象也进行拷贝。通过student1这个引用修改了m的值后，student2这个引用访问m的时候，值不会发生改变。
2.抽象类和接口的区别
抽象类和接口都是 Java 中多态的常见使用方式. 都需要重点掌握. 同时又要认清两者的区别，
核心区别: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法。
抽象类存在的意义是为了让编译器更好的校验, 像 Animal 这样的类我们并不会直接使用, 而是使用它的子类.万一不小心创建了 Animal 的实例, 编译器会及时提醒我们。
3.Object类
Object是Java默认提供的一个类。Java里面除了Object类，所有的类都是存在继承关系的。默认会继承Object父类。即所有类的对象都可以使用Object的引用进行接收。
例如：使用Object接收所有类的对象。。
class Person{
}
class Student{}
public class Test {
public static void main(String[] args) {
function(new Person());
function(new Student());
}
public static void function(Object object) {
System.out.println(object);
}}
Object类中有以下方法
4.获取对象的信息
如果要打印对象中的内容，可以直接重写Object类中的toString()方法。
// Object类中的toString()方法实现
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
5.对象比较方法equals
在Java中，==进行比较时：如果==左右两侧是基本类型变量，比较的是变量中值是否相同；
如果==左右两侧是引用类型变量，比较的是引用变量地址是否相同；如果要比较对象中内容，必须重写Object中的equals方法，因为equals方法默认也是按照地址比较的。
/ /Object类中的equals方法
public boolean equals(Object obj) {
return (this == obj); // 使用引用中的地址直接来进行比较
}class Person{
private String name ;
private int age ;
public Person(String name, int age) {this.age = age ;
this.name = name ;
}
}
public class Test {
public static void main(String[] args) {
Person p1 = new Person("zhangsan", 20) ;
Person p2 = new Person("lisi", 20) ;
int a = 10;
int b = 10;System.out.println(a == b);
System.out.println(p1 == p2);
System.out.println(p1.equals(p2));}
}
Person类重写equals方法后，然后比较：
class Person{
...
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false ;
}if(this == obj) {
return true ;
}// 不是Person类对象
if (!(obj instanceof Person)) {
return false ;
}Person person = (Person) obj ; // 向下转型，比较属性值
return this.name.equals(person.name) && this.age==person.age ;
}
}
结论：比较对象中内容是否相同的时候，一定要重写equals方法。
6.内部类
// OutClass是外部类public class OutClass {// InnerClass是内部类class InnerClass {}}
public class A {...}class B {...}//A、B是两个独立的类
根据内部类在一个类的位置可以分为实例内部类、静态内部类和局部内部类。
public class OutClass {//成员位置： 实例内部类（未被static修饰）public class InnerClass1{}// 成员位置：静态内部类static class InnerClass2{}public void method(){// 方法中定义内部类： 局部内部类：几乎不用class InnerClass5{}}}
public class OutClass {
private int a;
static int b;
int c;
public void methodA(){
a = 10;
System.out.println(a);
}
public static void methodB(){
System.out.println(b);
}
// 实例内部类：未被static修饰
class InnerClass{
int c;
public void methodInner(){
// 实例内部类中可以直接访问外部类中任意访问限定符修饰的成员
a = 100;
b =200;
methodA();
methodB();
// 如果具有相同名称成员时，优先访问的是内部类自己的
c = 300;
System.out.println(c);
// 如果要访问外部类同名成员，使用外部类名称.this.同名成员名字
OutClass.this.c = 400;
System.out.println(OutClass.this.c);
}
}
public static void main(String[] args) {
// 外部类：对象创建 以及 成员访问
OutClass outClass = new OutClass();
System.out.println(outClass.a);
System.out.println(OutClass.b);
System.out.println(outClass.c);
outClass.methodA();
outClass.methodB();
// 创建实例内部类对象
OutClass.InnerClass innerClass1 = new OutClass().new InnerClass();
// 也可以先将外部类对象先创建出来，然后再创建实例内部类对象(常用)
OutClass.InnerClass innerClass2 = outClass.new InnerClass();
innerClass2.methodInner();
}
}注意：外部类中的任何成员都可以在实例内部类方法中直接访问；实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束；实例内部类对象必须在先有外部类对象前提下才能创建 ；实例内部类的非静态方法中包含了一个指向外部类对象的引用；外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象。
2.静态内部类
public class OutClass {
private int a;
static int b;
public void methodA(){
a = 10;
System.out.println(a);
}
public static void methodB(){
System.out.println(b);
}
// 静态内部类：被static修饰的成员内部类
static class InnerClass{
public void methodInner(){
// 在内部类中只能访问外部类的静态成员
// a = 100; // 编译报错，a不是静态成员变量
b =200;
// methodA(); // 编译报错，methodB()不是静态成员方法
methodB();
}
}
public static void main(String[] args) {
// 静态内部类对象创建 、成员访问
OutClass.InnerClass innerClass = new OutClass.InnerClass();
innerClass.methodInner();
}
}注意：在静态内部类中只能访问外部类中的静态成员；创建静态内部类对象时，不需要先创建外部类对象。
3.匿名内部类
interface IA {
void test();
}
public class text {
public static void main(String[] args) {
//匿名内部类
IA a = new IA() {
@Override
public void test() {
System.out.println("这是重写了接口的方法！");
}
};
a.test();
new IA() {
@Override
public void test() {
System.out.println("这是重写了接口的方法！");
}
}.test();
}
}
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; 编译报错}}