内部类和Object类的深入了解

内部类和Object类的深入了解

内部类

Object类

equals与==的区别

1、成员内部类的特征及应用的代码展示：

package com.hwadee;
/*
 * 成员内部类访问外部类
 * 访问外部类的字段:外部类类名.this.字段
 * 访问内部类字段:this.字段
 * 访问内部类方法的局部变量:字段
 */
public class OuterClass {
    private String name="外部类属性";

    public static void main(String[] args) {
        //实例化外部类对象
        OuterClass oc=new OuterClass();
        //实例化内部类对象
        OuterClass.InnerClass ic=oc.new InnerClass();
        ic.addTail();

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

        //匿名对象方式访问
        new OuterClass().new InnerClass().addTail();

        //创建外部类对象
        Outer out=new Outer();
        //根据外部类对象创建内部类对象
        Outer.Inner in=out.new Inner();
        in.show();

    }
    private class InnerClass{//成员内部类，非静态内部类
        private String name="内部类属性";
        public void addTail() {
            //内部类访问外部类的情况
            String name="内部类局部变量";
            System.out.println("把   "+name+"    添加到尾巴上");
            System.out.println("把   "+this.name+"    添加到尾巴上");
            System.out.println("把   "+OuterClass.this.name+"    添加到尾巴上");

        }
    }

}
/*
 * 当需要在外部类访问非静态内部类时，该内部类不能是private修饰的，否则不能访问。
 * 非静态内部类对象是存放在外部类对象里的，因此在创建非静态内部类对象之前，必须先创建其外部类对象。
 * 格式:外部类对象名.new 内部类();
 */
class Outer{
    class Inner{//成员内部类，非静态内部类
        public void show() {
            System.out.println("非静态内部方法！！");
        }
    }
}

2、静态内部类的特征及应用的代码展示:

package com.hwadee;
/*
 * 使用static修饰内部类，该内部类属于其外部类，而不属于外部类的实例
 * 静态内部类不能访问外部类实例成员，只能访问外部类的静态成员
 */
public class StaticInnerClass_Test {

    public static void main(String[] args) {
        new Out().test();
        System.out.println("------------------------------");

        Outside.Inside.staticShow();//访问静态内部类静态方法
        new Outside.Inside().show();//访问静态内部类实例方法
    }

}
class Out{
    private String name="YaoMing";
    private static int age=34;
    static class  StaticInnerClass{
        private String message="hello world!";
        private static int num=11;
        public void show() {
            //System.out.println(name);   不能访问
            System.out.println(age);//可以访问
            System.out.println(new Out().name);
        }
    }
    public void test() {
        //System.out.println(message);  不能访问
        //System.out.println(num);   不能访问
        System.out.println(StaticInnerClass.num);
        System.out.println(new StaticInnerClass().message);
        new StaticInnerClass().show();

    }
}
/*静态内部类
 * 创建内部类对象的格式:new 外部类名.内部类名();
 * 静态内部类的全名应该是:外部类名.内部类名  所以要看作一个整体
 */
class Outside{
    static class Inside{
        public void show() {
            System.out.println("静态内部类实例方法！");
        }
        public static void staticShow() {
            System.out.println("静态内部类静态方法");
        }
    }

}

3、匿名内部类的特征及应用的代码展示:

package com.hwadee;
//匿名内部类的定义:只使用一次的类
public class AnonymousInnerClassImpl {
/*
 * 匿名内部类不能是抽象类，因为系统在创建匿名内部类的时候，会立即创建匿名内部类的对象
 * 匿名内部类不能定义构造器，因为匿名内部类没有类名
 * 匿名内部类必须继承一个父类或者实现一个接口，但最多只能一个父类或实现一个接口
 * 创建匿名内部类时会立即创建一个该类的实例，这个类定义立即显示，匿名内部类不能重复使用
 */
    public static void main(String[] args) {
        final String tempMessage="局部变量";
        test1(new AbstractSuperClass() {

            @Override
            public void show() {
                System.out.println(tempMessage);
                System.out.println("抽象类的匿名内部类实现");
            }
        });
        test2(new SuperInter() {

            @Override
            public void print() {
                System.out.println("接口的匿名内部类实现");
            }
        });
    }
    public static void test1(AbstractSuperClass asc) {
        //AbstractSuperClass,抽象类AbstractSuperClass的子类对象做参数
        asc.show();
    }
    public static void test2(SuperInter si) {
        //SuperInter,接口SuperInter的实现类对象做参数
        si.print();
    }

}
abstract class AbstractSuperClass{
    //AbstractSuperClass,并对该抽象类的抽象方法show()做声明
    public abstract void show();
}
interface SuperInter{
    //SuperInter,并对该接口的抽象方法print()做声明
    public abstract void print() ;
}

4、Object类的概述及应用的代码展示:

package com.hwadee;
//Object类是所有类的直接父类或间接父类
public class Object1 {
    public static void main(String[] args) {
        Student s1=new Student();
        s1.setAge(18);
        s1.setName("李明");
        int age1 = s1.getAge();
        String name1 = s1.getName();
        System.out.println("年龄="+age1+",名字="+name1);
        int a1=s1.hashCode();//返回该对象的哈希码值
        System.out.println(a1);

        Student s2=new Student();
        s2.setAge(19);
        s2.setName("张伟");
        int age2 = s2.getAge();
        String name2 = s2.getName();
        System.out.println("年龄="+age2+",名字="+name2);
        int a2=s2.hashCode();
        System.out.println(a2);

        Student s3=new Student();
        s3.setAge(19);
        s3.setName("张伟");
        int age3 = s3.getAge();
        String name3 = s3.getName();
        System.out.println("年龄="+age3+",名字="+name3);


        System.out.println(a1==a2);

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

        Class b1=s1.getClass();//返回此Object的运行时类
        System.out.println(b1);

        String b2=s1.getClass().getName();//获取对象的真实类的全名称
        System.out.println(b2);

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

        String c1=s1.toString();//返回该对象的字符串表示
        System.out.println(c1);
        String c3=s2.toString();
        System.out.println(c3);
        //若tostring方法没有重写，则输出内容与下面语句的输出内容一致
        String c2=s1.getClass().getName()+"@"+Integer.toHexString(s1.hashCode());
        System.out.println(c2);

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

        System.out.println(s1==s2);
        boolean equals1= s1.equals(s2);
        System.out.println(equals1);

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


        System.out.println(s2==s3);
        boolean equals2 = s2.equals(s3);
        System.out.println(equals2);


    }
}
class Student{
    int age;
    String name;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    @Override
    public String toString() {
        return "Student [age=" + age + ", name=" + name + "]";
    }   
}

5、equals方法与==号的区别:==是一个比较运算符号，既可以比较基本数据类型，也可以比较引用数据类型，基本数据类型比较的是值，引用数据类型比较的是地址值。equals方法是一个方法，只能比较引用数据类型，所有的对象都会继承Object类中的方法，如果没有重写Object类中的equals方法，equals方法和==号比较引用数据类型无区别，重写后的equals方法比较的是对象中的属性。