Java第十一天（内部类、、访问权限修饰符、Object类包括toString和equals方法重写）...

2019独角兽企业重金招聘Python工程师标准>>>

51.内部类（了解）

类内部的类就是内部类，可以无限层。

位置：把一个类定义到另一个类中，那么内部的类就是内部类。

注意：内部类不能直接创建

创建内部类的语法：

外部类.内部类 变量名 = new 外部类对象().new内部类对象()

内部类的外部类的方法如果想要访问内部类的方法，必须创建内部类的对象，根据内部类的对象来访问。

（1）普通内部类

内部类的特点：本类或者本类方法中可以直接创建内部类的对象,通过内部类对象可以调用内部类的属性和方法；

内部类和外部类对象都不能直接访问彼此的属性和方法

内部类的方法可以访问外部类的属性和方法，外部类的方法不能直接访问内部类的属性和方法但是可以通过内部类对象间接访问

//创建一个外部类
class Outter{
    String name;
    public void printOutter(){
            System.out.println("外部类方法！");
    }
    //创建一个内部类，内部类可以无限层
    class Inner{
        int age;
        //内部类的方法可以访问外部类的方法，但是外部类的方法不能访问内部类的方法
        public void printInner(){
            //调用外部类方法（不要加this）
            printOutter();
            System.out.println("内部类方法!");
        }
        //内部类的方法可以访问外部类的属性，但是外部类的方法不能访问内部类的属性
        public void introduceIn(){
            System.out.println("内部类方法打印姓名："+name+"年龄："+age);
        }
    }
    //本类之中可以直接创建内部类，但是内部类对象不能直接调用外部类的属性和方法
    public void method(){
        Inner i=new Inner();
        i.age=10;
        i.printInner();
        i.introduceIn();
    }

}
public class Test5{
    public static void main(String[] args){
        //创建一个内部类对象：外部类.内部类 变量名 = new 外部类对象().new内部类对象()
        Outter.Inner p=new Outter().new Inner();
        //内部类对象不能直接调用外部类的方法和属性
        p.age=12;
        p.printInner();
        p.introduceIn();
        //外部类对象不能直接调用内部类的属性和方法，但是可以间接调用
        Outter o=new Outter();
        o.name="pp";
        o.method();
    }
}

（2）匿名内部类（接口或者抽象类）

没有名字需要在接口或者抽象上实现的内部类

接口名 变量名=new 接口名（）{实现接口的方法};这个大括号就相当于一个内部类，别忘了分号

另外一种表现方式，new 接口名（）{实现接口的方法}.方法名（）;

interface Dog{
    public void speek();
}
public class Test{
    public static void main(String[] args){
        //接口名 变量名=new 接口名（）{实现接口的方法};这个大括号就相当于一个内部类，别忘了分号
        Dog p=new Dog(){
            String name="二哈";
            public void speek(){
                System.out.println(name+"冲着你汪汪汪!");
            }
        //别忘了这里的分号
        };
        p.speek();
        //另外一种表现方式，new 接口名（）{实现接口的方法}.方法名（）;
        new Dog(){
            public void speek(){
                System.out.println("冲着你汪汪汪!");
            }
        }.speek();
    }
}

abstract class Dog1{
    //抽象类中可以设置属性
    private String name;
    public Dog1(String name){
        this.name=name;
    }
    public void setName(String nm){
        name=nm;
    }
    public String getName(){
        return name;
    }
    public abstract void speek();
}
public class Test1{
    public static void main(String[] args){
        //接口名 变量名=new 接口名（）{实现接口的方法};这个大括号就相当于一个内部类，别忘了分号
        Dog1 p=new Dog1("二哈"){
            public void speek(){
                //调用封装方法得到私有属性
                System.out.println(getName()+"冲着你汪汪汪!");
            }
        //别忘了这里的分号
        };
        p.speek();
        //另外一种表现方式，new 接口名（）{实现接口的方法}.方法名（）;
        new Dog1("泰迪"){
            public void speek(){
                System.out.println(getName()+"冲着你汪汪汪!");
            }
        }.speek();
    }
}

52.访问权限修饰符

权限修饰符就是用来控制类属性，方法的访问的权限的标识

访问权限的修饰符一共有四种：private, 默认, protected, public

（1）访问权限修饰符修饰在类上：public修饰的类是可以随便访问，如果是默认修饰的同包可以访问，跨包不可访问

（包的知识点中已经讲过了，只有public的类不同包可以导入包再访问类）

（2）访问权限修饰符修饰在方法和属性上：

修饰同一个类中的方法或者属性可以被直接或者间接访问

修饰的方法或者属性，在同包不同类中可以被直接或间接访问

 

不同包不同类但为父子类的

无关类

类一般会用public修饰

属性一般用private修饰

方法一般用public，少数用protected、private修饰

53.Object类

Object是所有类的根类（默认隐藏地继承了objct类），所有的类都是直接或者间接的去继承Object类。

根类：最上层的类

超类：根类和父类之间的类

类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。

（1）toString方法

public String toString()

返回该对象的字符串表示。通常，toString 方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂的信息表达式。建议所有子类都重写此方法。

Object 类的 toString 方法返回一个字符串，该字符串由类名（对象是该类的一个实例）、at 标记符“@”和此对象哈希码的无符号十六进制表示组成。换句话说，该方法返回一个字符串，它的值等于：

getClass().getName() + '@' + Integer.toHexString(hashCode())

返回： 该对象的字符串表示形式。

toString方法在Object中的源码实现：

public String toString(){

     return getClass().getName()+'@'+Integer.toHexString(hashCode())

}

getClass().getName()    获得toString的方法的类的类名

Integer.toHexString(hashCode())   获得这个对象的hash值的16进制

hashCode方法      每一个对象都有唯一的一个hash值，不同的整数。

getClass方法     获得一个类的类对象

class Person{
    
}
public class Test2{
    public static void main(String[] args){
        Person p=new Person();
        int h=p.hashCode();
        System.out.println(h);
        System.out.println(Integer.toHexString(h));
        System.out.println(p.getClass());
        System.out.println(p.getClass().getName());
    }
}

（2）重写toString方法

class Person1{
    String name;
    String habit;
    public void speek(){
        System.out.println("你好！");
    }
    /*重写toString方法
    public String toString(){
        return getClass().getName()+'@'+Integer.toHexString(hashCode());
    }
    
    */
    public String toString(){
        speek();
        return "我是"+name+"我的爱好是"+habit;
    }
}
public class Test3{
    public static void main(String[] args){
        Person1 p=new Person1();
        p.name="小可爱";
        p.habit="撩小哥哥";
        //默认的调用了toString方法
        System.out.println(p);
    }
}

（3）finalize() 

面试题：

final、finally、finalize的区别

final作用在类上表示最后一个类不可被继承，修饰在方法上方法不可被覆写，修饰在属性上属性和变量上不可修改，属性可以在创建的时候赋予初始值或者构造器中赋予初始值（每个构造器都必须显示final这个属性的初始化）

（4）equals方法

==双等号

在Object中源码：

public boolean equals(Object obj){

    return  (this==objets);

}

基本数据类型比较的是值，各自有各自的默认值；

引用数据类型比较的是地址，默认值是null

（5）重写equals方法

class Child{
    String fa;
    String mo;
    int age;
    String face;
    /*重写equals方法
    public boolean equals(Object obj){
        return(this==obj);
    }
    */
    //重写规则:两个孩子的父亲和母亲一样，年龄相等、长相一样的是一胎生的
    public boolean equals(Object obj){
        //创建一个返回类型作为判断标识
        boolean flag=false;
        //判断是否来自于子类
        if(obj instanceof Child){
            //将自动转成父类的子类对象再转回子类，方便调用子类中的属性
            Child c=(Child)obj;
            //字符串类型调用equals方法需要判断字符串不为默认值
            if(this.fa==c.fa&&this.mo==c.mo&&this.age==c.age&&this.face!=null&&c.face!=null&&this.face.equals(c.face)){
                flag=true;
            }    
        }
        return flag;
    }
}
public class Test4{
    public static void main(String[] args){
        Child a=new Child();
        Child b=new Child();
        a.fa="dady";
        a.mo="mama";
        a.age=8;
        a.face="beautiful";
        b.fa="dady";
        b.mo="mama";
        b.age=8;
        b.face="beautiful";
        boolean x=a.equals(b);
        System.out.println(x);
        
    }
}

转载于:https://my.oschina.net/u/4110331/blog/3047670