object类和内部类

1.Object

object类是所有类的根类（父类）。

如果一个类没有显示继承另外一个类，那么该类一定继承于object类。

toString（）返回对象字符串的的形式。

public class Test01 {
    public static void main(String[] args) {
        Object obj = new Object();
        // 输出对象时，默认调用toString方法
        System.out.println(obj);
        // 类型@内存地址
        System.out.println(obj.toString());
        
        
        Student s1 = new Student("二狗",20);
        System.out.println(s1);
    }
}

可以通过代码生成器快速生成toString方法。

equals(object obj)用于判断两个对象是否相等。

==比较两个对象的内存地址或基本数据类型的或char类型比较，object默认equals实现比较内存地址。

equals：用于比较两个对象的内容（属性）是否相等。

当自定义对象时，要比较自定义对象是否相等，就必须通过equals方法比较两个对象属性值是否相等，那就必须重写Object的equals方法

public boolean equals(Object obj) {
        if(this == obj) {
            return true;
        }
        
        Student s = (Student) obj;
        if(this.sid.equals(s.sid) && this.name.equals(s.name) && this.age == s.age) {
            return true;
        }else {
            return false;
        }

}

2.内部类

在java中，一个文件可以定义多个类，但是文件名必须和public类型的类的类名保持一致。

这两个类是平行关系。

在java中，一个类也可以定义在一个类的内部，顾名思义定义在内部的类称为内部类（inter class），定义在外部的类称为外部类（out class）。

形如：

public class Outer {
    
    [修饰符] class Inner{
        
    }
}

 编译后的结果

内部类根据具体的修饰符和具体位置分为很多情况。

2.1成员内部类

一个内部类作为一个外部类的成员而存在，此时该内部类称为外部类的成员内部类。

public class Outer {
    
    class Inner{
        
    }
}

一般而言，内部类都用默认修饰符。

【1】内部类如何创建对象

public class Test01 {
    public static void main(String[] args) {
        
        // 【1】创建外部类对象
        Outer ot = new Outer;
        // 【2】创建内部类对象
        Inter it = ot.new Inter;
                it.showInfo;        
    }
}    

【2】内部类可以访问外部类的私有变量。

public class Outer {
    
    private String name = "Outer";
    
    class Inner{
        
        public void showInfo() {
            System.out.println(name);
        }
        
    }
}

【3】特殊情况内部类与外部类同名。

class Inner{
        
        private String name = "Inner";
        
        public void showInfo() {
            // String name = "show info";
            
            // 访问外部类的私有成员
            System.out.println(this.name);
            
            // 访问外部类的私有成员
            System.out.println(Outer.this.name);
            
        }
    }
}

静态内部类

如果一个内部类被static 修饰，我们称为这个类为静态内部类。形式

public class Outer {
    
    static class Inter{
        }
}

【1】静态内部类创建对象

public class Test01 {
    public static void main(String[] args) {
        
        // 【1】创建外部类对象
        Outer outer = new Outer();
        // 【2】创建内部类对象
        Inner inner = outer.new Inner();
        inner.showInfo();
    }
}

【2】内部类中可以访问外部类的私有变量

public class Outer {
    
    private String name = "Outer";
    
    class Inner{
        
        public void showInfo() {
            System.out.println(name);
        }
        
    }
}

【3】静态内部类可以访问外部类的（私有）静态成员

特殊情况:避免发生

public class Outer {
    
    private static String name = "Outer";
    
    static class Inner{
        
        private static String name = "Outer";
        
        public void showInfo() {
            System.out.println("showInfo");
            
            System.out.println(name);
            
            System.out.println(Outer.name);
        }
    }
}

方法内部类

如果一个内部类定义到一个方法中，我们称为方法内部类

public class Outer {
    private static int a = 5;
    public void print() {
        int b = 10;
        class Inner {
            public void showInfo() {
                System.out.println(b);
                
            }
        }
        Inner inner = new Inner();
        inner.showInfo();
    }
    
}

【2】方法的局部变量进入方法内部类时，被加上final 修饰。出了方法内部类之后，final被去掉

public class Outer {
    
    public void print(int b) {
        
        int a = 10;
        
        class Inner{
            
            public void showInfo() {
                System.out.println("show info");
                
                System.out.println("print()->a:"+10);
                
                // 在方法内部类中不能修改方法的局部变量(final)
                // a = 20;
                // b = 20;
            }
        }
        
        a = 20;
        
        Inner inner = new Inner();
        inner.showInfo();
    }
}

匿名内部类

未来一个类如果只使用一次，我们可以把类声明为匿名类。匿名类一般和内部类结合使用，形成匿名内部类

匿名内部类一定要存在：实现接口