Java 09 （内部类、引用类型、Object类）

一、内部类

  • 内部类定义:将一个类A定义在类B里面就是内部类,A就是内部类，则B就是外部类。
  • 格式：

格式:
class B{
class A{
}
}

1.1成员内部类

  • 访问成员内部类特点：

1.内部类可以直接访问外部成员，包括私有成员
2.外部类要访问内部类成员，必须要建立内部类的对象

  • 格式:
外部类名.内部类名 对象名 = new 外部类型（）.new 内部类型（）；
  • 例子：
public class Person {
    private boolean live = true;
    //创建内部类
    class Heart {
        public void jump(){
            //直接访问外部成员
            if (live){
                System.out.println("心扑通扑通地在跳");
            }else {
                System.out.println("over");
            }
        }
    }
    public boolean isLive(){
        return live;
    }
    public void setLive(boolean live){
        this.live = live;
    }
}
===================================================
public class InnerDemoTest {
    public static void main(String[] args) {
        //创建外部类对象
        Person person = new Person();
        // 创建内部类对象
        // 格式：外部类名.内部类名 对象名 = new 外部类型（）.new 内部类型（）;
        Person.Heart heart = person.new Heart();

        // 调用内部类方法
        heart.jump();

        // 调用外部类方法
        boolean live = person.isLive();
        System.out.println(live);
        person.setLive(false);

        heart.jump();
    }
}

1.2 匿名内部类(重点)

  • 它是内部类的简化写法
  • 本质:
    是一个带具体实现的、父类或者父接口的匿名的子类对象
    例子：

public abstract class FlyAble {
    // 抽象方法
    public abstract void fly();
}

public class InnerDemoTest2 {
    public static void main(String[] args) {
        FlyAble f =new FlyAble(){
            @Override
            public void fly() {
                System.out.println("我要起飞了");
            }
        };
        //调用fly方法
        f.fly();
    }
}
  • 以接口为例：当使用一个接口的时候，你似乎需要如下几步:
    1.定义一个子类
    2.重写接口中的方法
    3.创建子类对象
    4.调用重写后的方法
  • 我们的目的是调用重写后的方法，那么能否简化一下，把上面四步变成一步，答案是匿名内部类就可以做到.前提是匿名内部类必须继承一个父类或者实现一个父接口
  • 格式:
new 父类名或接口名(){
      // 方法重写
  @Override
     public void method(){
       //执行语句
} 
}
  • 例子：
public class InnerDemoTest3 {
    public static void main(String[] args) {
        /*
           1.等号右边，定义并创建该接口的子类对象
           2.等号左边，是多态，接口类型引用指向子类对象
         */
        FlyAble f = new FlyAble(){
            @Override
            public void fly() {
                System.out.println("我要起飞了");
            }
        };
        //将带有匿名内部类作为方法的参数进行传递
        showFly(f);
    }

    public static void showFly(FlyAble f){
        f.fly();
    }
}
===================================================

简化后写法：
public class InnerDemoTest4 {
    public static void main(String[] args) {
     //实际开发中常用的形式
        showFly(new FlyAble() {
            @Override
            public void fly() {
                System.out.println("我要起飞了");
            }
        });
        //将带有匿名内部类作为方法的参数进行传递
    }

    public static void showFly(FlyAble f) {
        f.fly();
    }
}

二、引用类型用法总结

  • 以前：基本类型可以作为成员变量，方法参数，方法的返回值类型
    现在：引用类型同样可以作为成员变量，方法参数，方法的返回值类型

2.1 class

  • class作为成员变量
// 添加武器属性
    private Weapon wp;
  • class作为方法参数
// 设置武器属性
        role.setWp(weapon);
  • class作为返回值类型
public int getHurt() {
        return hurt;
    }

  • 例子：吃鸡游戏

1.定义角色类:

package com.company;
//
public class Role {

    private int id; //角色id
    private int blood; //生命值
    private String name;//角色名

    // 添加武器属性
    private Weapon wp;

    // 添加盔甲属性
    private Armour ar;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getBlood() {
        return blood;
    }

    public void setBlood(int blood) {
        this.blood = blood;
    }

    public String getName() {
        return name;
    }

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

    public Weapon getWp() {
        return wp;
    }

    public void setWp(Weapon wp) {
        this.wp = wp;
    }

    public Armour getAr() {
        return ar;
    }

    public void setAr(Armour ar) {
        this.ar = ar;
    }
    // 添加攻击方法
    public void attack (){
        System.out.println("使用"+wp.getHurt()+",造成"+wp.getHurt()+"点伤害");
    }
    // 穿戴盔甲方法
    public void wear(){
        // 增加血量
        this.blood += ar.getProtect();
        System.out.println("穿上"+ar.getName()+",生命值增加"+ar.getProtect());
    }
}

2.定义武器类

package com.company;
//
public class Weapon {

    private String name;//武器名称
    private int hurt;//伤害值

    public Weapon(String name, int hurt) {
        this.name = name;
        this.hurt = hurt;
    }

    public String getName() {
        return name;
    }

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

    public int getHurt() {
        return hurt;
    }

    public void setHurt(int hurt) {
        this.hurt = hurt;
    }
}

3.定义盔甲类

package com.company;

public class Armour {

   private String name;// 装备名称
   private int protect;//防御值

   public Armour(String name, int protect) {
      this.name = name;
      this.protect = protect;
   }

   public String getName() {
      return name;
   }

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

   public int getProtect() {
      return protect;
   }

   public void setProtect(int protect) {
      this.protect = protect;
   }
}

4.测试：

package com.company;

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

        Weapon weapon = new Weapon("M4A1", 1212);

        Armour armour = new Armour("三级甲", 555);

        Role role = new Role();
        // 设置武器属性
        role.setWp(weapon);

        // 设置盔甲属性
        role.setAr(armour);
        role.attack();
        role.wear();
    }
}

2.2 interface 作为成员变量

  • 例子：王者荣耀游戏
    定义法术技能类：
package com.company;

public interface FaShuSkill {
    public abstract void faShuAttack();
}

定义角色类

package com.company;

public class WangZheRole {
    // 接口作为成员变量
    private FaShuSkill faShuSkill;

    public FaShuSkill getFaShuSkill() {
        return faShuSkill;
    }

    public void setFaShuSkill(FaShuSkill faShuSkill) {
        this.faShuSkill = faShuSkill;
    }

    // 发送法术攻击方法
    public void faShuSkillAttack(){
        System.out.println("开始发送法术攻击");
        faShuSkill.faShuAttack();
        System.out.println("技能释放完毕");
    }
}

测试：

package com.company;

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

        WangZheRole role = new WangZheRole();

        // 设置角色的法术技能
        role.setFaShuSkill(new FaShuSkill() {
            @Override
            public void faShuAttack() {
                System.out.println("发射爱心");
            }
        });

        // 发送法术攻击
        role.faShuSkillAttack();


        // 更换技能
        role.setFaShuSkill(new FaShuSkill() {
            @Override
            public void faShuAttack() {
                System.out.println("发射烤羊肉串");
            }
        });
        // 发送法术攻击
        role.faShuSkillAttack();

    }
}

2.3 interface 作为方法参数和返回值类型

package com.company;

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

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

        // 创建一个样本数据
        ArrayList<Integer> srcList = new ArrayList();
        for (int i = 0; i < 10; i++) {
            srcList.add(i);
        }

        // 调用获取所有偶数的方法
        List<Integer> list = getEvenNum(srcList);
        System.out.println(list);

    }
    // 获取某集合中所有的偶数
    // 1. 创建偶数集合
    // 此时List<Integer> list 作为了getEvenNum方法的参数
    public static List<Integer> getEvenNum(List<Integer> list){
        ArrayList<Integer> arrayList = new ArrayList<>();
        // 遍历集合
        for (int i = 0; i < list.size(); i++) {
            Integer integer = list.get(i);
            if (integer % 2 == 0){
                arrayList.add(integer);
            }
        }
        // 因为getEvenNum方法返回值类型是List<Integer>，arrayList是List的子类 所以arrayList是可以返回的
        //接口对应的类型作为返回值类型
        return arrayList;

    }
}

三、Java基础进阶高级API

3.1 Object类

概述：1.类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。
2.如果没有指定父类，默认继承Object
3.包含11个方法

public class MyClass /*extends Object*/ {
    // ...
}
  • toString方法

方法摘要:

1.public String toString()：返回该对象的字符串表示。
2.toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。
3.由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。

  • 覆盖重写
    如果不希望使用toString方法的默认行为，则可以对它进行覆盖重写。例如自定义的Person类：
public class Person {  
    private String name;
    private int age;

    @Override
    public String toString() {
        return "Person{" + "name='" + name + '\'' + ", age=" + age + '}';
    }

    // 省略构造器与Getter Setter
}

例子：
我们希望打印person对象时输出person类的基本信息，而不是他的地址值，此时就要重写toString方法

public class Person {
    private String name;
    private int age;
    private boolean live = true;

    public Person() {
    }

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

  @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", live=" + live +
                '}';
    }
  
}

public class Main{
    public static void main(String[] args) {
        Person person1 = new Person("皮皮虾",22);
        Person person2 = new Person("皮皮虾",22);
        Person person3 = new Person("皮皮虾",21);
        System.out.println(person1); //Person{name='皮皮虾', age=22, live=true}
        System.out.println(person1.equals(person2)); //true
        System.out.println(person1.equals(person3)); //false

    }

}
  • equals方法
  • 方法摘要:

1.public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。
2.调用成员方法equals并指定参数为另一个对象，则可以判断这两个对象是否是相同的。这里的“相同”有默认和自定义两种方式。
3.默认是地址值的比较 ==，只要不是同一个对象，必然是false

@Override
    // 比较原则，name和age相同 就是同一个person
    public boolean equals(Object o) {
        // 如果对象地址一样 ，则认为相同
        if (this == o)
            return true;
        // 如果参数为空，或者类型不一样 则认为不同
        if (o == null || getClass() != o.getClass())
            return false;
        // 转换为当前类型
        Person person = (Person) o;
        // 应用类型比较相等使用 Java,util.Objects的equals静态方法取得结果
        return age == person.age && Objects.equals(name,(person.name));
    }

getClass():返回此 Object 的运行时类

  • Objects类（工具类）

  • 在比较两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中的equals方法就优化了这个问题。
    方法如下：
    public static boolean equals(Object a, Object b):判断两个对象是否相等。

public static boolean equals(Object a, Object b) {  
    return (a == b) || (a != null && a.equals(b));  
}

四、System类

  • java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作，在System类的API文档中.
1System.currentTimeMillis()：返回以毫秒为单位的当前时间。

2.public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：
将数组中指定的数据拷贝到另一个数组中。

ublic class SystemClassTest {
    public static void main(String[] args) throws InterruptedException {
        //获取当前系统时间与1970年01月01日00：00之间的毫秒差
//        System.out.println(System.currentTimeMillis());
//        long start = System.currentTimeMillis();
//        //程序
//        for (int i = 0; i < 10 ; i++) {
//            System.out.println(i);
//        }
//        long end = System.currentTimeMillis();
//        System.out.println("共耗时" + (end - start) + "毫秒");
//    }
        long start = System.currentTimeMillis();
        System.out.println(start);
        Thread.sleep(3600); //进程执行时间
        long end = System.currentTimeMillis();
        System.out.println(end);
        System.out.println("共耗时" + (end - start) + "毫秒");
    }
}
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。