Java编程 Javase07

一、内部类

1、概念：如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类。

• 例如：身体和心脏的关系，又如汽车和发动机的关系。

2、分类

• 成员内部类、局部内部类（包含匿名内部类）

3、成员内部类

（1）定义格式：

修饰符 class 外部类名称{
    修饰符 class 内部类名称{
        //...
    }
    //...
}

• 注意：内用外，随便访问。外用内，需要内部类对象。

（2）使用

• 间接使用：在外部类的方法中，使用内部类，然后主函数只是调用外部类的方法。
• 直接方式：

外部类名称.内部类名称 对象名=new 外部类名称().new 内部类名称();

//创建一个外部类用来储存学生的初始属性
public class students_score {
    public students_score(String name) {
        this.name = name;
    }
    private String name;


    public String getName() {
        return name;
    }

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

    //定义一个外部类方法
    public void show(){
        System.out.println("你的姓名为："+getName());
        //在外部类方法中创建一个内部类对象
        subject_score stu1=new subject_score();
        stu1.show_score("math",68);
    }
    //定义一个内部类
    public class subject_score{
        //定义一个内部类方法
        public void show_score(String subject,double score){
            //内部可以直接调用外部类的方法和成员变量
            //如show(zhangsan)，以及下面的getName
            System.out.println(getName()+"，你的科目为："+subject);
            System.out.println(getName()+"，你的成绩为："+score);
        }
    }
}

public class score {
    public static void main(String[] args) {
        //间接访问：创建外部类，但要求外部类的方法中包括内部类，通过访问外部类的方法来访问内部类
        students_score stu1 = new students_score("zhangsan");
        stu1.show();
        //直接访问，利用公式
        students_score.subject_score stu2 =new students_score("lisi").new subject_score();
        stu2.show_score("history",89);

    }
}

输出为：
你的姓名为：zhangsan
zhangsan，你的科目为：math
zhangsan，你的成绩为：68.0
lisi，你的科目为：history
lisi，你的成绩为：89.0

（3）内部类的同名变量访问

•  局部变量采用就近原则。
• 内部类的成员变量使用this（谁用就是谁）
• 外部类的成员变量：

外部类名称.this.成员变量名

• 例如：

public class number {
    int number =10;
    public class num{
        int number=20;
        public void num0(){
            System.out.println(number);//20
            System.out.println(this.number);//20
            System.out.println(number.this.number);//10
        }
    }

}

public class main2 {
    public static void main(String[] args) {
        number.num number0 = new number().new num();
        number0.num0();
    }
}
//输出为：20 20 10

4、局部内部类

（1）定义：如果一个类是定义在一个方法内部的，那么这就是一个局部内部类

• 局部：只有当前所属的方法才能使用它，出了这个方法外面就不能再使用了。

//定义格式：
修饰符 class 外部类名称{
    修饰符 返回值类型 外部类方法名称（参数列表）{
        class 局部内类名称{
            //...
        }
    }
}

（2）类的权限修饰符：

• public > protected > (defualt) > private

（3）定义一个类的时候，权限修饰符规则

• 外部类：public/（default）
• 成员内部类：public/ protected/(default)/private
• 局部内部类：什么都不写

//创建一个局部类：定义在方法中的类
public class suiyuan {
    public void method(){
        class suibian{
            int num =10;
            public void m(){
                System.out.println(num);
            }
        }
        //创建一个内部类
        suibian bian=new suibian();
        bian.m();
    }
}

public class sui {
    public static void main(String[] args) {
        suiyuan yang = new suiyuan();
        //yang.method();
        /*只能调用创建的外部类的方法，不能调用方法的内部类
        如果需要调用内部类方法需要在外部类方法内调用*/
        yang.method();
    }
}
//输出结果为10

（4）局部内部类的final问题

• 局部内部类如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】，实际就是将变量变成常量。
• 从Java8开始只要局部变量事实不变，那么这个final关键字可以省略。
• 原因：

1. new出来的对象在堆内存中
2. 局部变量是跟着方法走的，在堆内存中
3. 方法运行结束之后，立刻出栈，局部变量就会立刻消失
4. new出来的对象会在堆当中持续存在，直到垃圾回收消失。

public class a {
    public void method(){
        final int num =10;//final可以省略
        class b{
            public void m(){
                System.out.println(num);
            }
        }
    }
}

5、匿名内部类

•  如果接口的实现类或者是父类的子类只需要使用的唯一一次，那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】。

（1）匿名内部类的定义格式：

接口名称 对象名 =new 接口名称（）{
    覆盖重写所有抽象方法
}

  

//定义一个接口并定义一个抽象方法
public interface a {
    void method();
}

public class b {
    public static void main(String[] args) {

        a sui = new a() {
            @Override
            public void method() {
                System.out.println("方法实现！");
            }
        };
        sui.method();
    }
}
//输出为：方法实现！

（2）匿名内部类注意事项

• new代表创建对象的动作
• 接口名称就是匿名内部类需要，大括号内是匿名内部类的内容
• 匿名内部类，在创建对象的时候只能使用唯一的一次。如果希望多次创建对象而且类的内容一样的话，那么就必须使用单独定义的实现类了。
• 匿名对像在调用方法的时候只能能调用唯一一次。如果希望同一对象调用多次方法，那么必须给对象取名。
• 匿名内部类省略了实现类/子类，匿名对象是省略了对象名称。
• 注意，匿名内部类和匿名对象不是同一件事。

public class c {
    public static void main(String[] args) {
        new a() {
            @Override
            public void method() {
                System.out.println("匿名对象使用了方法!");
            }
        }.method();//如果需要调用多次方法，建议为对象命名。
    }
}
//输出为：匿名对象使用了方法!

6、类作为成员变量类型

• 类也可也作为成员变量被使用

public class only {
    private String onlyone;
    public only(){

    }

    public only(String onlyone) {
        this.onlyone = onlyone;
    }

    public String getOnlyone() {
        return onlyone;
    }

    public void setOnlyone(String onlyone) {
        this.onlyone = onlyone;
    }
}

public class people {
    private String name;
    private int age;
    //将only类作为一个成员变量
    private only gexing;

    public people(){

    }
    public people(String name, int age, only gexing) {
        this.name = name;
        this.age = age;
        this.gexing = gexing;
    }
    public void girl (String girlname){
        System.out.println(name+age+"岁"+",喜欢"+gexing.getOnlyone() +",他的女朋友叫"+girlname);
    }
    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 only getGexing() {
        return gexing;
    }

    public void setGexing(only gexing) {
        this.gexing = gexing;
    }
}

public class person {
    public static void main(String[] args) {

        people man=new people();
        man.setName("张三");
        man.setAge(20);
        only a=new only("吉他");
        man.setGexing(a);
        man.girl("MIss who.");

    }
}
//输出结果为：张三20岁,喜欢吉他,他的女朋友叫MIss who

7、接口作为成员变量类型

public interface gituar {
    void perform();
}

public class person {
    private String name;
    //将gituar作为成员变量
    private gituar song;
    public person() {

    }

    public person(String name, gituar song) {
        this.name = name;
        this.song = song;
    }
    public void tan(String girlname,String songname){
        System.out.println(name+"用吉他为"+girlname+"谈唱一首"+songname);
        song.perform();
    }

    public String getName() {
        return name;
    }

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

    public gituar getSong() {
        return song;
    }

    public void setSong(gituar song) {
        this.song = song;
    }
}

public class catchheart {
    public static void main(String[] args) {
        person man=new person();
        man.setName("李四");
        man.setSong(new gituar() {
            @Override
            public void perform() {
                System.out.println(man.getName()+"俘获了她的心");
            }
        });
        man.tan("不知道小姐","往后余生");
    }
}
/*输出为：李四用吉他为不知道小姐谈唱一首往后余生
          李四俘获了她的心*/

8、接口作为参数的方法和返回值

• 例如，java.util.list正是ArrayList所实现的接口

import java.util.ArrayList;
import java.util.List;

public class suiyuan {
    public static void main(String[] args) {
        //左边是接口名称，右边是实现类名称
        List<String> lady= new ArrayList<>();
        List<String> girls=name(lady);
        //遍历集合
        for (int i = 0; i < girls.size(); i++) {
            System.out.println(girls.get(i));
        }
    }
    //将接口作为返回值类型和参数名称
    public static List<String> name(List<String> list){
        list.add("不知道小姐");
        list.add("Miss Who");
        list.add("找不到女士");
        return list;
    }
}

//输出结果为：
不知道小姐
Miss Who
找不到女士

二、Object类

• Object类是Java语言中的根（最顶层）类，及所有类的父类。它中描述的所有方法子类都可以使用，在对象实例化时，最终找的父类就是Object。
• 如果一个类没有特别指定父类，那么默认就是继承Object类。

1、Object的to String方法

• to String（）返回该对象的字符串表示。直接打印对象的名字其实就是调用to String方法，打印的实际为对象的地址值。因此需要重写Object类的toString方法。
• 重写时可以使用快捷键（alt+insert）直接重写。
• 看一个类是否重写了toString方法，直接打印这个类对应的对象名字即可。如果没有重写则打印地址值，如果重写了toString方法，那么就按照重写的方式打印。

public class person {
    private String name;
    private int age;

    public person(){

    }

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

    @Override
    //重写toString方法
    public String toString() {
        return "person{" +
                "name='" + name + '\'' +
                ", 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;
    }
}

 

import java.util.ArrayList;
import java.util.Random;

public class a {
    public static void main(String[] args) {
        person p=new person();
        p.setAge(18);
        p.setName("张三");
        System.out.println(p);

        Random r = new Random();
        //因为Random没有重写toString方法，所以输出的结果为地址值。
        System.out.println(r);

        ArrayList<Integer> list =new ArrayList<>();
        list.add(1);
        list.add(2);
        //Arraylist重写了toString方法，输出结果为集合
        System.out.println(list);
    }
}

person{name='张三', age=18}
java.util.Random@52cc8049
[1, 2]

2、Object类的equals方法

• 指示某个对象是否与此对象相等

public class b {
    public static void main(String[] args) {
        person a=new person("zhaosi",19);
        person b=new person("zhangsan",19);
        boolean c=a.equals(b);
        System.out.println(c);
        /*基本类型：比较值
        引用类型：比较地址值
        所以输出的结果为false
         */
    }
}

3、重写Object类的equals方法

•  Object类的equals方法的地址值，没有意义。所以我们需要重写equals方法，比较两个对象的属性值。
• equals方法中隐含一个多态，因此需要使用向下转型。
• 重写时可以直接使用快捷键，建议使用JDK版本

  @Override
    public boolean equals(Object o) {
        if (this == o) return true;//判断是否为本身
        if (o == null || getClass() != o.getClass()) return false;//判断是否为空
        person person = (person) o;//向下转型
        return age == person.age &&
                name.equals(person.name);
    }

 person a=new person("zhaosi",19);
        person b=new person("zhaosi",19);
        boolean c=a.equals(b);
        System.out.println(c);
//输出为true

• Objects类的equals方法：对两个对象进行比较可以防止空指针异常

public class c {
    public static void main(String[] args) {
        String s1="aaa";
        String s2=null;
        boolean a= Objects.equals(s1,s2);
        System.out.println(a);
    }
}
//输出结果为false

4、Object类与Objects类

（1）Object类

• Object类是所有类的父类，一个类都会直接或间接的继承自该类中提供了一些非常常用的方法。
• toString（）方法equals（）方法

（2）Objects类

• equals方法