Java 接口与继承笔记

最新推荐文章于 2021-11-10 20:26:42 发布

王加油

最新推荐文章于 2021-11-10 20:26:42 发布

阅读量95

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/oldwangold/article/details/97631134

版权

Java 专栏收录该内容

39 篇文章 0 订阅

订阅专栏

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();
    }   
}

王加油

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java 接口与继承笔记

1. Object 类是所有类的父类；声明一个类的时候，默认是继承了 Object2. Object 类提供了一个 toString方法，所以所有的类都有 toString 方法toString() 的意思是返回当前对象的字符串表达。通过 System.out.println 打印对象就是打印该对象的 toString() 返回值3. finalize()当一个对象没有...
复制链接

扫一扫