Java 接口与继承 笔记

 

1. Object 类是所有类的父类；声明一个类的时候，默认是继承了 Object

2. Object 类提供了一个 toString 方法，所以所有的类都有 toString 方法

• toString() 的意思是返回当前对象的字符串表达。
• 通过 System.out.println 打印对象就是打印该对象的 toString() 返回值

3. finalize() 

• 当一个对象没有任何引用指向的时候，它就满足垃圾回收的条件。
• 当它被垃圾回收的时候，它的 finalize() 方法就会调用。
• finalize() 不是开发人员主动调用的方法，而是由虚拟机 JVM 调用的。

4. equals() 

equals() 用于判断两个对象的内容是否相同。

当两个英雄的 hp 相同的时候，我们就认为这两个英雄相同。

public class Hero {
    public String name;
    protected float hp;
      
    public boolean equals(Object o){
        if(o instanceof Hero){
            Hero h = (Hero) o;
            return this.hp == h.hp;
        }
        return false;
    }
      
    public static void main(String[] args) {
        Hero h1= new Hero();
        h1.hp = 300;
        Hero h2= new Hero();
        h2.hp = 400;
        Hero h3= new Hero();
        h3.hp = 300;
         
        System.out.println(h1.equals(h2)); //false
        System.out.println(h1.equals(h3)); //true
    }
}

5. == 和 hashCode()

这不是 Object 的方法，但是用于判断两个对象是否相同。

更准确的说，用于判断两个引用，是否指向同一个对象。

hashCode 方法返回一个对象的哈希值。默认情况下，Object 类的 hashCore() 方法根据该对象的地址来计算。

但很多类都重写了 Object 类的 hashCode() 方法，不再根据地址来计算其 hashCode() 方法值。

public class Hero {
    public String name;
    protected float hp;
      
    public boolean equals(Object o){
        if(o instanceof Hero){
            Hero h = (Hero) o;
            return this.hp == h.hp;
        }
        return false;
    }
      
    public static void main(String[] args) {
        Hero h1= new Hero();
        h1.hp = 300;
        Hero h2= new Hero();
        h2.hp = 400;
        Hero h3= new Hero();
        h3.hp = 300;
        Hero h4 = h1;
         
        System.out.println(h1==h2); //false
        System.out.println(h1==h3); //false
        System.out.println(h1==h4); //true
        System.out.println("h1.hashCode:"+h1.hashCode()); //h1.hashCode:2018699554
        System.out.println("h2.hashCode:"+h2.hashCode()); //h2.hashCode:1311053135
        System.out.println("h3.hashCode:"+h3.hashCode()); //h3.hashCode:118352462
        System.out.println("h4.hashCode:"+h4.hashCode()); //h4.hashCode:2018699554

    }
}

final

final 修饰类，方法，基本类型变量，引用的时候分别有不同的意思。

1. final 修饰类

当 Hero 被修饰成 final 的时候，表示 Hero 不能够被继承。

2. final 修饰方法

Hero 的useItem 方法被修饰成 final，那么giant方法在 ADHero 中，不能够被重写。

3. final 修饰基本变量

final 修饰基本变量，表示该变量只有一次赋值机会。

4. final 修饰引用

表示该引用只有 1 次指向对象的机会。

抽象类

在类中声明一个方法，这个方法没有实现体，只是一个“空”方法。

这样的方法就叫抽象方法，使用修饰符“abstract”

当一个类有抽象方法的时候，该类必须被声明为抽象类。

1. 抽象类

为 Hero 增加一个抽象方法 attack，并且把 Hero 声明为 abstract 的。

APHero，ADHero，ADAPHero 是 Hero 的子类，继承了 Hero 的属性和方法。

但各自的共计手段是不一样的，所有继承 Hero 类后，这些子类就必须提供不一样的 attack 方法实现。

2. 抽象类可以没有抽象方法

Hero 类可以在不提供抽象方法的前提下，声明为抽象类。

一旦一个类被声明为抽象类，就不能被直接实例化。

package charactor;
   
public abstract class Hero {
    String name;
          
    float hp;
          
    float armor;
          
    int moveSpeed;
       
    public static void main(String[] args) {
        //虽然没有抽象方法，但是一旦被声明为了抽象类，就不能够直接被实例化
        Hero h= new Hero(); //error
    }
          
}

3. 抽象类和接口的区别

区别一：

• 子类只能继承一个抽象类，不能继承多个
• 子类可以实现多个接口

区别二：

• 抽象类可以定义：public，protected，package，private；静态属性和非静态属性；final和非final属性。
• 接口中声明的属性只能是：public，静态，final。

内部类

内部类分为四种：

• 非静态内部类
• 静态内部类
• 匿名类
• 本地类

1. 非静态内部类

非静态内部类 BattleScore “战斗成绩”

非静态内部类可以直接在一个类里面定义。比如：

• 战斗成绩只有在一个英雄存在的时候才有意义
• 所以实例化 BattleScore 的时候，必须建立在一个存在的英雄的基础上
• 语法： new 外部类().new 内部类()
• 作为 Hero 的非静态内部类，是可以直接访问外部类的 private 实例属性 name 的

public class Hero {
    private String name; // 姓名
    float hp; // 血量
    float armor; // 护甲
    int moveSpeed; // 移动速度
 
    // 非静态内部类，只有一个外部类对象存在的时候，才有意义
    // 战斗成绩只有在一个英雄对象存在的时候才有意义
    class BattleScore {
        int kill;
        int die;
        int assit;
 
        public void legendary() {
            if (kill >= 8)
                System.out.println(name + "超神！");
            else
                System.out.println(name + "尚未超神！");
        }
    }
 
    public static void main(String[] args) {
        Hero garen = new Hero();
        garen.name = "盖伦";
        // 实例化内部类
        // BattleScore对象只有在一个英雄对象存在的时候才有意义
        // 所以其实例化必须建立在一个外部类对象的基础之上
        BattleScore score = garen.new BattleScore();
        score.kill = 9;
        score.legendary();
    }
 
}

2. 静态内部类

一个类里面声明一个静态内部类

• 比如敌方水晶，当敌方水晶没有血的时候，己方所有的英雄都取得胜利，而不只是某一个具体的英雄取得胜利。
• 与非静态内部类不同，静态内部类水晶类的实例化不需要一个外部类的实例为基础，可以直接实例化。
• 语法：new 外部类.静态内部类();
• 因为没有一个外部类的实例，所以在静态内部类里面不可以访问外部类的实例属性和方法。
• 除了可以访问外部类的私有静态成员外，静态内部类和普通类没什么大的区别。

public class Hero {
    public String name;
    protected float hp;
  
    private static void battleWin(){
        System.out.println("battle win");
    }
    
    //敌方的水晶
    static class EnemyCrystal{
        int hp=5000;
        //如果水晶的血量为0，则宣布胜利
        public void checkIfVictory(){
            if(hp==0){
                Hero.battleWin();
                 
                //静态内部类不能直接访问外部类的对象属性
                System.out.println(name + " win this game"); //error
            }
        }
    }
     
    public static void main(String[] args) {
        //实例化静态内部类
        Hero.EnemyCrystal crystal = new Hero.EnemyCrystal();
        crystal.checkIfVictory();
    }
}

3. 匿名类

匿名类指的是在声明一个类的同时实例化它，使代码更加简洁精炼。

• 通常情况下，要使用一个接口或者抽象类，都必须创建一个子类。
• 有时候，为了快速使用，直接实例化一个抽象类，并当场实现其抽象方法。
• 既然实现了抽象方法，那么就是一个新的类，只是这个类，没有命名。

这样的类，叫做匿名类。

public abstract class Hero {
	String name; //姓名
	float hp; //血量
	float armor; //护甲
	int moveSpeed; //移动速度
	
	public abstract void attack();
	
	public static void main(String[] args) {
		ADHero adh = new ADHero();
		//通过打印adh，可以看到adh这个对象 属于ADHero类
		adh.attack();
		System.out.println(adh);
		
		Hero h = new Hero() {
			//当场实现attack方法
			public void attack() {
				System.out.println("新的进攻手段");
			}
		};
		h.attack();
		//通多打印h，可以看到h这个对象属于Hero$1这么一个系统自动分配的类名
		System.out.println(h);
	}
}

4. 本地类

• 本地类可以理解为有名字的匿名类
• 内部类与匿名类不一样的是，内部类必须声明在成员的位置，即与属性和方法平等的位置。
• 本地类和匿名类一样，直接声明在代码块里面，可以是主方法，for 循环里等等地方。

public abstract class Hero {
    String name; //姓名  
    float hp; //血量  
    float armor; //护甲   
    int moveSpeed; //移动速度
      
    public abstract void attack();
      
    public static void main(String[] args) {
          
        //与匿名类的区别在于，本地类有了自定义的类名
        class SomeHero extends Hero{
            public void attack() {
                System.out.println( name+ " 新的进攻手段");
            }
        }
         
        SomeHero h  =new SomeHero();
        h.name ="地卜师";
        h.attack();
    }   
}