javaSE-day01-Objects工具类的equals方法

day11/src/com/inmind/class_member_var09/Armor.java

@@ -0,0 +1,28 @@
+package com.inmind.class_member_var09;
+
+//防御装类
+public class Armor {
+    private String name;
+    private int protectNum;//防御值
+
+    public Armor(String name, int protectNum) {
+        this.name = name;
+        this.protectNum = protectNum;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public int getProtectNum() {
+        return protectNum;
+    }
+
+    public void setProtectNum(int protectNum) {
+        this.protectNum = protectNum;
+    }
+}

day11/src/com/inmind/class_member_var09/Demo07.java

@@ -0,0 +1,46 @@
+package com.inmind.class_member_var09;
+/*
+类作为成员变量类型(hero,weapon,armor)
+案例：英雄角色，获取武器，获取防御装，闯关
+ */
+public class Demo07 {
+    public static void main(String[] args) {
+        //创建英雄角色对象
+        Hero hero = new Hero();
+        hero.setName("德玛西亚");
+
+        //打怪，掉落武器
+        Weapon weapon = new Weapon("屠龙刀", 999);
+        hero.setWeapon(weapon);
+        //打怪，掉落防具
+        Armor armor = new Armor("复活甲", 888);
+        hero.setArmor(armor);
+
+        //打boss
+        hero.attack();
+        //boss回击
+        hero.protect();
+
+        System.out.println("BOSS掉落了一本技能书");
+        Skill skill = new Skill() {
+            @Override
+            public void outSkill() {
+                System.out.println("施放野火燎原技能，团队伤害9999");
+            }
+
+            @Override
+            public String getName() {
+                return "野火燎原";
+            }
+        };
+        //装备技能
+        hero.setSkill(skill);
+        //英雄获取自己的技能，并施放
+        hero.getSkill().outSkill();
+
+
+        System.out.println("游戏结束");
+
+    }
+
+}

day11/src/com/inmind/class_member_var09/Hero.java

@@ -0,0 +1,78 @@
+package com.inmind.class_member_var09;
+
+import java.util.ArrayList;
+
+public class Hero {
+    private String name;
+    private Weapon weapon;
+    private Armor armor;
+
+    //背包
+    private ArrayList<Weapon> weapons;
+    //拥有技能
+    private Skill skill;
+
+    public Skill getSkill() {
+        return skill;
+    }
+
+    public void setSkill(Skill skill) {
+        this.skill = skill;
+        System.out.println("英雄"+this.name+"装备了技能-"+this.skill.getName());
+    }
+
+    public Hero() {
+    }
+
+    public Hero(String name, Armor armor, Weapon weapon) {
+        this.name = name;
+        this.armor = armor;
+        this.weapon = weapon;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public Weapon getWeapon() {
+        return weapon;
+    }
+
+    public void setWeapon(Weapon weapon) {
+        this.weapon = weapon;
+        System.out.println("英雄"+this.name+"装备了"+this.weapon.getName());
+    }
+
+    public Armor getArmor() {
+        return armor;
+    }
+
+    public void setArmor(Armor armor) {
+        this.armor = armor;
+        System.out.println("英雄"+this.name+"装备了"+this.armor.getName());
+    }
+
+    public ArrayList<Weapon> getWeapons() {
+        return weapons;
+    }
+
+    public void setWeapons(ArrayList<Weapon> weapons) {
+        this.weapons = weapons;
+    }
+
+    //行为
+    //攻击
+    public void attack(){
+        System.out.println(this.name+"使用了-"+this.weapon.getName()+"-武器，输出了"+this.weapon.getHurt()+"伤害");
+    }
+
+    //防御
+    public void protect(){
+        System.out.println(this.name+"穿戴了-"+this.armor.getName()+"-防具，抵消了"+this.armor.getProtectNum()+"伤害");
+    }
+
+}

day11/src/com/inmind/class_member_var09/Skill.java

@@ -0,0 +1,8 @@
+package com.inmind.class_member_var09;
+
+public interface Skill {
+    //施放技能的方法
+    void outSkill();
+
+    String getName();
+}

day11/src/com/inmind/class_member_var09/Weapon.java

@@ -0,0 +1,28 @@
+package com.inmind.class_member_var09;
+
+//武器类
+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;
+    }
+}

day11/src/com/inmind/final_class01/Demo01.java

@@ -0,0 +1,20 @@
+package com.inmind.final_class01;
+/*
+final:被final修饰的内容，不能够被改变的
+
+final:被它修饰的内容，不能够被改变
+final有4个用法：
+1.修饰类
+2.修饰方法
+3.修饰成员变量
+4.修饰局部变量
+--------------------------------------
+final关键字用于修饰类:该类就不能被继承
+final与abstract是冲突，不能一起使用
+被final修饰的类，叫“太监类”,最终类,无法继承
+作用（目的）：不允许修改该类的功能！！
+
+
+ */
+public class Demo01 {
+}

day11/src/com/inmind/final_class01/Fu.java

@@ -0,0 +1,9 @@
+package com.inmind.final_class01;
+
+public final class Fu {
+    int num = 10;
+
+    public void method(){
+        System.out.println("父类的method方法");
+    }
+}

day11/src/com/inmind/final_local_var03/Demo03.java

@@ -0,0 +1,41 @@
+package com.inmind.final_local_var03;
+
+import java.util.Arrays;
+
+/*
+final关键字用于修饰局部变量
+局部变量：
+1.基本数据类型：保存的值真正的值，表示该值赋值之后不能被修改的
+2.引用数据类型: 保存的值是地址值。引用数据类型地址不变，所指向的内容可以改变
+
+
+ */
+public class Demo03 {
+    public static void main(String[] args) {
+        method();
+    }
+
+    public static void method(){
+        //基本数据类型的局部变量
+        final int i = 10;
+        //i = 20;//被final修饰的局部变量，不能被修改
+        System.out.println(i);
+        System.out.println("=========================");
+
+        //引用数据类型的局部变量
+        /*int[] arr1 = new int[4];
+        int[] arr2 = new int[]{1,2,3};*/
+        final int[] arr = {1,2,3};//arr中保存是地址值
+        System.out.println(Arrays.toString(arr));
+        arr[0] = 10;
+        arr[1] = 20;
+        arr[2] = 30;
+        System.out.println(Arrays.toString(arr));
+
+        //类的对象
+        final Student s = new Student(18, "张三");
+        s.setName("张三丰");
+        System.out.println(s.getName());
+
+    }
+}

day11/src/com/inmind/final_local_var03/Student.java

@@ -0,0 +1,27 @@
+package com.inmind.final_local_var03;
+
+public class Student {
+    private int age;
+    private String name;
+
+    public Student(int age, String name) {
+        this.age = age;
+        this.name = 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;
+    }
+}

day11/src/com/inmind/final_member_var04/Fu.java

@@ -0,0 +1,17 @@
+package com.inmind.final_member_var04;
+/*
+final关键字用于修饰成员变量
+注意：被final修饰成员变量，必须【手动赋值】
+ */
+public class Fu {
+   final int j;//成员变量
+
+    //在构造方法中对成员变量赋值
+    public Fu(int j){//构造方法的作用：创建对象，并给属性赋值
+        this.j = j;//注意点，构造方法中可以给被final修饰未赋值的成员变量进行赋值
+    }
+
+    public void method(){
+        int i = 10;
+    }
+}

day11/src/com/inmind/final_method02/Demo02.java

@@ -0,0 +1,13 @@
+package com.inmind.final_method02;
+
+public class Demo02 {
+    public static void main(String[] args) {
+        //创建一个父类对象
+        Fu fu = new Fu();
+        fu.method();
+        //多态的写法：
+        Fu f = new Zi();//格式：父类引用指向子类对象
+        //编译看左边，运行看右边
+        f.method();
+    }
+}

day11/src/com/inmind/final_method02/Fu.java

@@ -0,0 +1,9 @@
+package com.inmind.final_method02;
+/*
+final关键字用于修饰方法:该方法就不能被子类重写
+ */
+public class Fu {
+    public final void method(){
+        System.out.println("父类的method方法");
+    }
+}

day11/src/com/inmind/final_method02/Zi.java

@@ -0,0 +1,14 @@
+package com.inmind.final_method02;
+
+public class Zi extends Fu{
+    //ctrl+o
+
+    /*@Override
+    public void method() {
+        //super.method();//调用父类的成员方法，沿用
+        System.out.println("子类的method方法,重写了父类的功能");
+    }*/
+
+    public void methodZi(){
+    }
+}

day11/src/com/inmind/limit_05/Class1.java

@@ -0,0 +1,19 @@
+package com.inmind.limit_05;
+/*
+接口中定义5种内容：常量、抽象方法、默认方法、静态方法、私有方法
+选择流程：switch  case   default
+ */
+public class Class1 {
+    //设置4种权限的静态变量
+    private static int num1 = 1;
+    static int num2 = 2;
+    protected static int num3 = 3;
+    public static int num4 = 4;
+
+    public static void method(String[] args) {
+        System.out.println(num1);
+        System.out.println(num2);
+        System.out.println(num3);
+        System.out.println(num4);
+    }
+}

day11/src/com/inmind/limit_05/Class2.java

@@ -0,0 +1,10 @@
+package com.inmind.limit_05;
+
+public class Class2 {
+    public static void main(String[] args) {
+//        System.out.println(Class1.num1);//同一个包中只有私有内容无法访问
+        System.out.println(Class1.num2);
+        System.out.println(Class1.num3);
+        System.out.println(Class1.num4);
+    }
+}

day11/src/com/inmind/limit_05/Demo04.java

@@ -0,0 +1,12 @@
+package com.inmind.limit_05;
+/*
+四种权限修饰符:权限修饰符，可以用来修饰类，方法，成员变量
+                        public      >       protected       >       (default)       >       private
+在同一个类中              YES                 YES                     YES                     YES
+在同一包中                YES                 YES                     YES                     NO
+在不同包中（父子类关系）    YES                 YES                     NO                      NO
+在不同包中（!父子类关系）   YES                 NO                      NO                      NO
+ */
+public class Demo04 {
+
+}

day11/src/com/inmind/limit_05/sub/Class3.java

@@ -0,0 +1,13 @@
+package com.inmind.limit_05.sub;
+
+import com.inmind.limit_05.Class1;
+
+public class Class3 extends Class1 {
+    public static void main(String[] args) {
+        //注意：在不同包，有父子关系类中，只有public protected可以访问
+        /*System.out.println(Class1.num1);
+        System.out.println(Class1.num2);*/
+        System.out.println(Class1.num3);
+        System.out.println(Class1.num4);
+    }
+}

day11/src/com/inmind/limit_05/sub/Class4.java

@@ -0,0 +1,13 @@
+package com.inmind.limit_05.sub;
+
+import com.inmind.limit_05.Class1;
+
+public class Class4 {
+    public static void main(String[] args) {
+        //注意：在不同包，没有父子关系类中，只有public 可以访问
+        /*System.out.println(Class1.num1);
+        System.out.println(Class1.num2);
+        System.out.println(Class1.num3);*/
+        System.out.println(Class1.num4);
+    }
+}

day11/src/com/inmind/local_innerclass07/OuterClass.java

@@ -0,0 +1,39 @@
+package com.inmind.local_innerclass07;
+
+import com.inmind.member_innerclass06.Member_Outer_Class;
+
+/*
+局部内部类定义(方法中)
+局部内部类的格式：
+public class 外部类名{
+    方法修饰符 返回值类型 成员变量名（参数列表）{
+        class 局部内部类名{
+
+        }
+    }
+}
+
+注意：局部内部类是定义在方法中，只能够在该定义方法中使用
+ */
+public class OuterClass {//外部类
+
+    //成员方法
+    public void method(){
+        int num = 10;//局部变量
+        //局部内部类
+        class InnerClass{
+            int num = 20;
+            static int i = 30;
+            public void innerMethod(){
+                System.out.println(num);
+            }
+        }
+
+        InnerClass innerClass = new InnerClass();
+        System.out.println(innerClass.num);
+        innerClass.innerMethod();
+    }
+
+    public void method1(){
+    }
+}

day11/src/com/inmind/member_innerclass06/Demo05.java

@@ -0,0 +1,10 @@
+package com.inmind.member_innerclass06;
+/*
+内部类：将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。
+分类：
+1.成员内部类：（类中方法外）
+2.局部内部类：（方法中）
+    匿名内部类(重点)
+ */
+public class Demo05 {
+}

day11/src/com/inmind/member_innerclass06/Member_Outer_Class.java

@@ -0,0 +1,39 @@
+package com.inmind.member_innerclass06;
+/*
+成员内部类的定义(写在成员位置)
+public class 外部类名{
+    int i = 0;
+    public class 内部类名{
+    }
+}
+
+------------------------------
+成员内部类中内容访问的注意事项：
+1.内部类是可以直接使用外部类的成员变量
+2.外部类要使用内部类的内容，必须通过创建内部类的对象
+3.在内部类中不能使用static修饰,跟内部类的生命周期有关(JDK17之前不行！！！)
+4.内部类访问外部类同名变量：必须使用外部类名.this.变量名（如OuterClass.this.value）
+
+ */
+public class Member_Outer_Class {
+    int i = 10;//成员变量
+    //成员内部类
+    public  class InnerClass{
+        static int value = 30;
+        int innerI = 20;
+        int i = 20;
+        public void innerMethod(){
+            System.out.println(value);
+            System.out.println(i);
+            System.out.println(Member_Outer_Class.this.i);
+            System.out.println(innerI);
+        }
+    }
+
+
+    public void method(){
+        InnerClass innerClass = new InnerClass();
+        InnerClass.value = 50;
+        innerClass.innerMethod();
+    }
+}

day11/src/com/inmind/noname_innerclass08/AbstractClass.java

@@ -0,0 +1,5 @@
+package com.inmind.noname_innerclass08;
+
+public abstract class AbstractClass {
+    public abstract void method1();
+}

day11/src/com/inmind/noname_innerclass08/Animal.java

@@ -0,0 +1,10 @@
+package com.inmind.noname_innerclass08;
+
+public class Animal {
+    int age;
+    String name;
+
+    public void eat(){
+        System.out.println("动物要吃吃吃");
+    }
+}

day11/src/com/inmind/noname_innerclass08/Demo06.java

@@ -0,0 +1,93 @@
+package com.inmind.noname_innerclass08;
+/*
+匿名内部类:定义在方法中的一个没有名字的类
+
+之前我们使用的一个类的子类，或者接口的实现类时，必定要先定义.java文件，再创建出对象，调用方法，但是
+如果该子类或者实现类只用一次，那么.java文件就有点多余了，这时就可以使用匿名内部类
+
+匿名内部类定义：
+{
+
+    @Override
+    public void method() {
+        System.out.println("匿名内部类的method方法被调用了");
+    }
+};
+
+ 必须跟new 接口名（匿名内部类定义） ，new 抽象类名（匿名内部类定义），new 普通类名（匿名内部类定义）后面。
+ */
+public class Demo06 {
+
+    public static void main(String[] args) {
+        //普通接口的使用
+        MyInterfaceImpl impl = new MyInterfaceImpl();
+        impl.method();
+        //多态的使用：父类引用指向子类对象
+        MyInterface impl1 = new MyInterfaceImpl();
+        impl1.method();
+
+        //能不能将MyInterfaceImpl.java这个类的定义，直接省略掉，那就使用匿名内部类
+        MyInterface impl2 = new MyInterface(){
+
+            @Override
+            public void method() {
+                System.out.println("匿名内部类中的method方法被调用了");
+            }
+        };
+        impl2.method();
+        //---------------------------------------------------
+        //抽象父类的匿名内部类
+        // 使用AbstractClass，但是不定义出它的子类的java文件，使用匿名内部类
+        AbstractClass ac = new AbstractClass(){
+            @Override
+            public void method1() {
+                System.out.println("匿名内部类（子类）实现了抽象父类的method1方法");
+            }
+        };
+        ac.method1();
+        //-----------------------------------------------------
+        //普通类的匿名内部类
+        Animal dog = new Animal(){
+            @Override
+            public void eat() {
+                System.out.println("狗吃骨头");
+            }
+        };
+        dog.eat();
+
+
+        //匿名内部类和匿名对象
+        //new Scanner(System.in).nextInt();//匿名对象
+
+        /*
+        new MyInterface(){
+            @Override
+            public void method() {
+                System.out.println("匿名内部类中的method方法被调用了");
+            }
+        } 是匿名对象
+
+        {
+            @Override
+            public void method() {
+                System.out.println("匿名内部类中的method方法被调用了");
+            }
+        }是匿名内部类
+
+
+         */
+        new MyInterface(){
+            @Override
+            public void method() {
+                System.out.println("匿名内部类中的method方法被调用了");
+            }
+        }.method();
+
+
+    }
+
+
+    public void method(){
+
+    }
+}

day11/src/com/inmind/noname_innerclass08/MyInterface.java

@@ -0,0 +1,5 @@
+package com.inmind.noname_innerclass08;
+
+public interface MyInterface {
+    void method();
+}

day11/src/com/inmind/noname_innerclass08/MyInterfaceImpl.java

@@ -0,0 +1,8 @@
+package com.inmind.noname_innerclass08;
+
+public class MyInterfaceImpl  implements  MyInterface{
+    @Override
+    public void method() {
+        System.out.println("MyInterfaceImpl类中的method方法被调用了");
+    }
+}

javaSE-day01/src/com/inmind/object01/Demo01.java

@@ -0,0 +1,14 @@
+package com.inmind.object01;
+/*
+Object:是所有类的父类,java中所有的类直接或者间接继承自Object
+ */
+public class Demo01 {
+    public static void main(String[] args) {
+        //普通创建对象
+        Person p = new Person();
+        Student s = new Student();
+        //多态创建对象
+        Person p1 = new Student();
+
+    }
+}

javaSE-day01/src/com/inmind/object01/Demo02.java

@@ -0,0 +1,37 @@
+package com.inmind.object01;
+
+import java.util.ArrayList;
+
+/*
+Object类的toString方法
+    String toString() 返回对象的字符串表示形式。
+
+Object类的toString的源码：
+public String toString() {
+        return getClass().getName() + "@" + Integer.toHexString(hashCode());
+    }
+
+注意:在实际开发中,一个对象的地址值对于我们而言,没有太大的帮助,我们程序员希望直接看到
+    该对象的内容(属性)，那怎么办呢？？？
+
+现在父类Object类的toString功能,不符合子类Person的需求,那么我们就可以在对应的子类中重写toString
+
+总结:今后打印对象时,如果发现打印时输出了地址,但是我们想看属性内容,应该在该对象的类中重写toString，
+    不用手动写alt+insert自动生成即可
+ */
+public class Demo02 {
+    public static void main(String[] args) {
+        Person p = new Person();
+        p.age = 20;
+        p.name = "张三";
+        System.out.println(p);//com.inmind.object01.Person@3b07d329，此处调用的是Object的toString方法
+
+        ArrayList<Integer> lists = new ArrayList<>();
+        lists.add(1);
+        lists.add(2);
+        lists.add(3);
+        //为何现在打印对象内容变了？？因为println(Object):底层调用的是该对象的toString方法并返回，但是ArrayList重写了父类的toString方法
+        System.out.println(lists);//[1, 2, 3]
+
+    }
+}

javaSE-day01/src/com/inmind/object01/Demo03.java

@@ -0,0 +1,42 @@
+package com.inmind.object01;
+
+import java.util.ArrayList;
+
+/*
+Object类
+boolean equals(Object obj) 判断2个对象的内容是否相同
+
+在实际开发中，地址值对于我们而言没有太大的作用，比较关心的数据内容，经常将内容相同的
+    2个对象，看作是同一个
+
+对于引用数据类型：
+    ==：比较的是地址值
+    equals：比较的是内容
+
+Object类底层equals源码：
+    public boolean equals(Object obj) {
+        return (this == obj);
+    }
+
+如果父类的内容比较功能equals，不符合子类需求，那就重写equals方法即可
+
+总结：每个对象的equals方法继承自Object类，默认使用==比较地址值，这个对于我们而言，不满足咱们需求
+        因此我们会在每个类中重写equals方法，不用手动写，直接alt+insert自动生成
+ */
+public class Demo03 {
+    public static void main(String[] args) {
+        //引用数据类型
+        String s1 = "abc";
+        String s2 = "abc";
+
+        System.out.println(s1 == s2);//true 比较的是地址
+
+        //引用数据类型Person
+        Person p1 = new Person("张三", 20);
+        Person p2 = new Person("张三", 20);
+        System.out.println(p1 == p2);//false
+        System.out.println(p1.equals(p2));//true
+
+
+    }
+}

javaSE-day01/src/com/inmind/object01/Person.java

@@ -0,0 +1,58 @@
+package com.inmind.object01;
+
+import java.util.Objects;
+
+public class Person {//直接继承自Object
+    String name;
+    int age;
+
+    public Person() {
+    }
+
+    public Person(String name, int age) {
+        this.name = name;
+        this.age = age;
+    }
+
+    @Override
+    public String toString() {
+        return "Person{" +
+                "age=" + age +
+                ", name='" + name + '\'' +
+                '}';
+    }
+
+    /*@Override
+    public boolean equals(Object obj) {
+        //我希望在Person比较时，只比较内容(姓名和年龄)，而不是地址
+        //只要姓名和年龄是一致的，那就是同一个人
+        //先直接判断地址是否相同，如果地址相同，则认为内容相同
+        if (this == obj) {
+            return true;
+        }
+        //先判断类型，如果类型不一致，则认为内容不同
+        if (obj instanceof Person) {
+            //如果是同一个类型，则进行属性的比较
+            Person p2 = (Person) obj;
+            Person p1 = this;
+            *//*if (p1.name.equals(p2.name) && p1.age == p2.age) {
+                return true;
+            } else {
+                return false;
+            }*//*
+            return p1.name.equals(p2.name) && p1.age == p2.age;
+        } else {
+            return false;
+        }
+
+    }*/
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == null || this.getClass() != o.getClass()) return false;
+
+        Person person = (Person) o;
+        return age == person.age && Objects.equals(name, person.name);
+    }
+
+}

javaSE-day01/src/com/inmind/object01/Student.java

@@ -0,0 +1,4 @@
+package com.inmind.object01;
+
+public class Student extends  Person{//间接继承自Object
+}

javaSE-day01/src/com/inmind/objects02/Demo04.java

@@ -0,0 +1,28 @@
+package com.inmind.objects02;
+
+import com.inmind.object01.Person;
+
+import java.util.Objects;
+
+/*
+    4.Objects类的equals方法
+    static boolean equals(Object a, Object b) 返回 true如果参数相等，彼此 false否则。
+
+    Objects类的equals方法的作用:在实现判断2个对象是否相同的基础上,有效地避免空指针异常
+ */
+public class Demo04 {
+    public static void main(String[] args) {
+        Person p1 = new Person("张三", 20);
+        Person p2 = new Person("张三", 20);
+        //普通的判断写法
+        System.out.println(p1.equals(p2));//true
+        //不小心，将p1初始化了
+//        p1 = null;
+
+        /*if (p1 != null){
+            System.out.println(p1.equals(p2));
+        }*/
+        System.out.println(Objects.equals(p1, p2));
+        //请问Objects.equals，它本身有比较内容的功能吗？？？没有，它使用的是p1对象的equals方法
+    }
+}