Java基础（11）内部类、Object类

1.内部类

1. 内部类的概述：把类定义在其他类的内部，这个类就称为内部类
2. 内部类访问的特点
（1）内部类可以直接访问外部类的成员，包括私有
（2）外部类要访问内部类的成员，必须要先创建对象
3. 内部类的分类：根据内部类在外部类的定义位置不同，分成成员内部类和局部内部类
4. 成员内部类
（1）成员内部类的定义位置：类中方法外
（2）创建成员内部类对象：外部类民.内部类名 对象名 = new 外部类名().new 内部类名

public class TestDemo01 {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer().new Inner();
        inner.inShow();
        System.out.println(inner.num3);

        System.out.println("==================");

        Outer outer = new Outer();
        outer.outTest();
    }
}

class Outer{
    int num = 20;
    private double num2 = 3.14;
    public void outShow(){
        System.out.println("外部类的成员方法outShow");
    }

    //定义成员内部类
    class Inner{
        int num3 = 30;
        public void inShow(){
            System.out.println("内部类的inShow方法");
            System.out.println(num);
            System.out.println(num2);
            System.out.println(num3);
            outShow();
        }
    }

    //外部类想要访问内部类的成员，要创建内部类对象
    public void outTest(){
        Inner inner = new Inner();
        System.out.println(inner.num3);
        inner.inShow();
    }
}

（3）private修饰成员内部类：为保证数据的安全性。private修饰的内部类为私有内部类，外界不能直接创建其对象了。如果要访问内部类的成员，需要通过创建外部类的对象来间接访问

public class TestDemo02 {
    public static void main(String[] args) {
        Wai wai = new Wai();
        wai.waiHaHa();
    }
}

class Wai{
    int a = 20;
    private int b = 10;

    public void waiShow(){
        System.out.println("waiShow方法执行");
    }

    private void waiTest(){
        System.out.println("外部类的私有方法");
    }

    private class Nei{
        int c = 233;
        public void neiShow(){
            System.out.println(a);
            System.out.println(b);
            waiShow();
            waiTest();
        }
    }

    public void waiHaHa(){
        Nei nei = new Nei();
        System.out.println(nei.c);
        nei.neiShow();
    }
}

（4）static修饰成员内部类：为了方便访问数据。需要注意的是：①静态内部类访问的外部类数据必须用静态修饰。②成员方法可以是静态的或者非静态的。③成员内部类被static修饰后的访问方式是：外部类名.内部类名 对象名 = new 外部类名.内部类名()；

public class TestDemo01 {
    public static void main(String[] args) {
        Wai.Nei nei = new Wai.Nei();
        System.out.println(nei.c);
        nei.neiShow();
    }
}

class Wai{
    private int num = 100;
    private double d = 3.14;
    public void waiShow(){
        System.out.println("waiShow方法执行了");
    }

    public static void waiShow2(){
        System.out.println("静态的waiShow2执行了");
    }

    public static class Nei{
        int c = 20;
        public void neiShow(){
//            System.out.println(num);  //错误 num没有被static修饰
//            waiShow();   //错误 waiShow()没有被static修饰
            waiShow2();
        }
    }
}

（5）一道面试题

//要求：使用已知的变量，在控制台输出30，20，10。
	class Outer {
		public int num = 10;
		class Inner {
			public int num = 20;
			public void show() {
				int num = 30;
				System.out.println(num);  //30
				System.out.println(this.num);  //20
				System.out.println(Outer.this.num);   //10 【重点】
			}
		}
	}
	class InnerClassTest {
		public static void main(String[] args) {
			Outer.Inner oi = new Outer().new Inner();
			oi.show();
		}	
	}

5. 局部内部类【用得不多】
（1）局部内部类的定义位置：类中方法内
（2）局部内部类在外界不能直接访问内部类的成员，需要通过外部类的对象来间接访问内部类成员

public class TestDemo01 {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.test();
    }
}

class Outer{
    int num = 20;
    private double a = 3.14;
    public void test(){
        //定义局部内部类
        class Inner{
            int b = 30;
            public void neiShow(){
                System.out.println(num);
                System.out.println(a);
                waiShow();
            }

            public void neiTest(){
                System.out.println(b);
            }
        }

        //创建内部类对象
        Inner inner = new Inner();
        inner.neiTest();
    }

    private void waiShow(){
        System.out.println("外部类show方法");
        test();
    }
}

（3）局部内部类访问外部类的局部变量必须用final修饰，在JDK1.8之后，final会默认加上。

public class TestDemo02 {
}

class Wai{
    int num = 100;
    public void waiTest(final int i){ //局部变量
        final int a = 200;  //局部变量

        class Nei{
            int j = 20;
            public void neiShow(){
                num = 300;
                System.out.println(num);
            }
        }
    }
}

6. 匿名内部类【重点】
（1）匿名内部类的概述：局部内部类的一种简化写法
（2）前提：存在一个类或者接口（这里的类可以是具体类也可以是抽象类）
（3）匿名内部类的本质：是一个继承了该类或者实现了该接口的子类对象
（4）格式：new 类名或者接口名() { 重写方法 }；

//重写一个类
public class TestDemo01 {
    public static void main(String[] args) {

        //想要得到AA的子类对象，使用匿名内部类
        new AA(){
            @Override
            public void aa() {
                System.out.println("aaaaa");
            }

            @Override
            public void bb() {
                System.out.println("bbbbb");
            }
        }.aa;    //aaaaa
        
        new AA(){
            @Override
            public void aa() {
                System.out.println("aaaaa");
            }

            @Override
            public void bb() {
                System.out.println("bbbbb");
            }
        }.bb;    //bbbbb
        
    }
}

class AA{
    public void aa(){

    }

    public void bb(){

    }
}

//重写一个接口
public class TestDemo02 {
    public static void main(String[] args) {
        new LOL() {
            @Override
            public void attack() {
                System.out.println("平A");
            }
        }.attack();    //平A
    }
}

interface LOL{
    void attack();
}

public class TestDemo01 {
    public static void main(String[] args) {
   		//使用同一个对象，多态
        LOL lol = new LOL() {
            @Override
            public void attack() {
                System.out.println("普通攻击");
            }

            @Override
            public void magic() {
                System.out.println("魔法攻击");
            }
        };
        
        lol.attack();
        lol.magic();
    }
}

abstract class LOL{
    public abstract void attack();
    public abstract void magic();
}

（5）匿名内部类的应用：可以作为参数来传递，或作为返回值返回
①匿名内部类作为参数来传递

public class TestDemo01 {
    public static void main(String[] args) {
        //当你以后看到一个方法的形参，要一个接口类型，你就可以传递一个该接口的子类对象。
        test(new LOL() {
            @Override
            public void attack() {
                System.out.println("普通攻击");
            }
        });  //普通攻击

    }

    public static void test(LOL lol){
        lol.attack();
    }
}

interface LOL{
    void attack();
}

public class TestDemo02 {
    public static void main(String[] args) {
        set(new Test() {
            @Override
            public void show() {
                System.out.println("重写show方法");
            }
        });   //重写show方法
    }

    public static void set(Test test){
        test.show();
    }
}

abstract class Test{
    public abstract void show();
}

②匿名内部类作为返回值

public class TestDemo01 {
    public static void main(String[] args) {
        MyInterface myInterface = test();
        myInterface.show();  //重写的show方法
    }

    public static MyInterface test(){
        MyInterface myInterface = new MyInterface() {
            @Override
            public void show() {
                System.out.println("重写的show方法");
            }
        };

        return myInterface;
    }
}

interface MyInterface{
    void show();
}

（6）匿名内部类中this关键字的应用

public class TestDemo01 {
    public static void main(String[] args) {
        new Inter(){
            public void show(){
                //this代表接口的子类对象
                System.out.println(this.a);  //23
                System.out.println(Inter.a);  //23
            }
        }.show();
    }
}

interface Inter{
    public static final int a =23;
}

2.Object类

1. Object类概述：所有类的根类，所有类都直接或者间接继承自Object类
2. 构造方法：public Object（） //子类的构造方法默认访问的是父类的无参构造方法
3. Object类的hashCode()方法
（1）public int hashCode()
（2）返回该对象的哈希码值。①默认情况下根据该对象的地址值计算。②不同对象的hashCode值不同，同一个对象的hashCode值肯定相同

public class TestDemo01 {
    public static void main(String[] args) {
        Object obj1 = new Object();
        System.out.println(obj1);   //java.lang.Object@3f99bd52
        int code = obj1.hashCode();
        System.out.println(code);   //1067040082

        Object obj2 = new Object();
        System.out.println(obj2);   //java.lang.Object@4f023edb
        int code2 = obj2.hashCode();
        System.out.println(code2);   //1325547227

        System.out.println(code == code2);    //false
    }
}

4. Object类的getClass()方法
（1）public final Class getClass()
（2）获取这个类的字节码文件对象。因为一个类的字节码文件就一份，你一加载进内存，就为这个字节码文件创建了一个对象。你不管通过该类的哪个对象去获取这个类的字节码文件对象，都是同一个字节码对象

public class TestDemo02 {
    public static void main(String[] args) {
        Object obj1 = new Object();
        Class<?> aClass1 = obj1.getClass();
        System.out.println(aClass1);   //class java.lang.Object

        Object obj2 = new Object();
        Class<?> aClass2 = obj2.getClass();
        System.out.println(aClass2);   //class java.lang.Object

        System.out.println(obj1 == obj2);   //false
        System.out.println(aClass1 == aClass2);  //true
    }
}

5. Object类的toString()方法
（1）public String toString()
（2）返回该对象的地址值。我们在输出一个对象的名称时，默认调用父类的toString()方法，打印该对象的地址值
（3）重写toString()方法：打印成员变量的值

public class TestDemo03 {
    public static void main(String[] args) {
        LOL lol1 = new LOL("VN",23);
        System.out.println(lol1.toString());   //LOL{name='VN', age=23}

        LOL lol2 = new LOL("EZ",15);
        System.out.println(lol2.toString());   //LOL{name='EZ', age=15}
    }
}

class LOL{
    private String name;
    private int age;

    public LOL() {
    }

    public LOL(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }


    //重写toString方法
    @Override
    public String toString() {
        return "LOL{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

6. Object类的equals()方法
（1）public boolean equals(Object obj)
（2）默认情况下是比较地址值是否相同
（3）重写equals()方法：比较成员变量的值是否相同

public class TestDemo01 {
    public static void main(String[] args) {
        LOL lol1 = new LOL("酒桶",48);
        LOL lol2 = new LOL("酒桶",48);
        LOL lol3 = new LOL("EZ",15);

        boolean b1 = lol1.equals(lol2);
        System.out.println(b1);   //true

        boolean b2 = lol1.equals(lol3);
        System.out.println(b2);   //false
    }
}

class LOL{
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public LOL(String name, int age) {

        this.name = name;
        this.age = age;
    }

    public LOL() {

    }


    //重写equals()方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        LOL lol = (LOL) o;
        return age == lol.age &&
                Objects.equals(name, lol.name);
    }

}

7. Object类的clone()方法
（1）clone()的权限修饰符是受保护的，在使用的时候要重写该类方法，把该方法的权限修饰符变成public
（2）clone()方法采用的是浅克隆的方式
（3） 如果一个对象需要调用clone的方法克隆，那么该对象所属的类必须要实现Cloneable接口
（4）Cloneable接口只不过是一个标识接口而已，没有任何方法
（5）对象的浅克隆也不会调用到构造方法的。

public class TestDemo01 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Dog dog1 = new Dog("小白",2);
        Dog dog2 = (Dog) dog1.clone();

        System.out.println(dog2.name);   //小白
        System.out.println(dog2.age);   //2
    }
}

class Dog implements Cloneable{
    String name;
    int age;

    public Dog() {
    }

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public Object clone() throws CloneNotSupportedException{
        return super.clone();
    }
}

（6） 对象的浅克隆就是克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象，这时候只是克隆另外一个对象的地址，而没有把另外一个对象也克隆一份