Java教程

JAVA学习笔记(第五章 接口与继承)

本文主要是介绍JAVA学习笔记(第五章 接口与继承),对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

一、什么是接口

        接口就像是一种模板,接口中放着没有内容的方法,类要是使用接口就必须声明接口中的方法。下面继续以LOL游戏为例:

LOL的英雄,有些能够使用物理攻击,有些能够使用魔法攻击击,有些则两种攻击都能使用,因此可以将英雄分为ADHero类、APHero和ADAPHero类,其继承了Hero 类,继承了name,hp,armor等属性。

        以物理攻击为例,声明一个方法 physicAttack 物理攻击,其即在ADHero类中,也在ADAPHero类中,一种方法是在ADHero类中定义physicAttack 方法,ADAPHero类再继承ADHero类;而另一种方法就是使用接口。(为什么用要用接口而不一直使用继承呢,之后会补上)

        定义一个AD接口,里面提供了physicAttack()方法,但是没有方法体,是一个“空”方法。

interface AD {
    public void physicAttack();//物理攻击
}

        ADHero类实现AD接口,使用关键字 implements(这类似于继承extends),而且必须声明AD中的方法。

public class ADHero extends Hero implements AD{
 
    @Override
    public void physicAttack() {
        System.out.println("进行物理攻击");
    } 
}

        同理,我们可以创建AP接口,ADAPHero类同时实现AD、AP接口。

public class ADAPHero extends Hero implements AD,AP{
  
    @Override
    public void magicAttack() {
        System.out.println("进行魔法攻击");
    }
  
    @Override
    public void physicAttack() {
        System.out.println("进行物理攻击");
    }  
}

二、对象转型

1.引用类型?对象类型?

public class MAIN {   
    public static void main(String[] args) {        
        ADHero ad = new ADHero();  
        Hero h = new ADHero();       
    }
}

        通过之前的学习我们可以知道,第一个对象是ADHero(),引用是ad,其类型都是ADHero(一般情况下,引用类型和对象类型是一样的);第二个对象是ADHero(),引用是h,对象的类型是ADHero,引用的类型是Hero。

        当引用、对象类型不同时,只能使用引用类型中的方法,即h只能使用Hero中的方法,而ADHero中新增的不行。

2.类型转换

(1)类与类的转换

        和基本类型转换相似,子类转父类能够自动转,而父类转子类需要强转,但风险自担(很简单AD英雄是英雄,英雄可不一定是AD英雄),当然没有继承关系的两个类互相转换,一定会失败。

 

         但是转完之后,h依然不能使用ADHero()中的方法。

(2)类与接口的转换

        引用ad指向的对象是ADHero类型,这个类型实现了AD接口。从语义上来讲,把一个ADHero当做AD来使用,而AD接口只有一个physicAttack方法,这就意味着转换后就有可能要调用physicAttack方法,而ADHero一定是有physicAttack方法的,所以转换是能成功的。(即类转接口一定可以)

public static void main(String[] args) {
    ADHero ad = new ADHero();          
    AD adi = ad;
}

       第四行:adi实际上是指向一个ADHero的,所以能够转换成功。
       第五行:adi引用所指向的对象是一个ADHero,要转换为ADAPHero就会失败。    

public static void main(String[] args) {
    ADHero ad = new ADHero();            
    AD adi = ad;   
    ADHero adHero = (ADHero) adi;            
    ADAPHero adapHero = (ADAPHero) adi;
    adapHero.magicAttack();
}

3.  instanceof   

        判断一个引用所指向的对象,是否是Hero类型,或者Hero的子类

public static void main(String[] args) {
    ADHero ad = new ADHero();
    APHero ap = new APHero();
         
    Hero h1= ad;
    Hero h2= ap;
         
    //判断引用h1指向的对象,是否是ADHero类型
    System.out.println(h1 instanceof ADHero);
         
    //判断引用h2指向的对象,是否是APHero类型
    System.out.println(h2 instanceof APHero);
         
    //判断引用h1指向的对象,是否是Hero的子类型
    System.out.println(h1 instanceof Hero);
}

三、重写

        重写很简单,就是子类使用了父类的方法,但是子类想做出点改变。比如Hero类中有attack()方法,产生的效果是进行攻击,而ADHero也有attack(),但是产生的效果是进行AD攻击。

class Hero {
    public void attack() {
        System.out.println(" 进行了一次攻击");
    }
}
class ADHero extends Hero {
    public void attack() {
        System.out.println(" 进行了一次AD攻击");
    }
}

        可想而知,如果没有重写这样的机制,子类,一旦继承了父类,所有方法都不能修改了。但是子类又希望提供一点不同的功能,为了达到这个目的,只能放弃继承父类,重新编写所有的属性和方法,然后在编写effect的时候,做一点小改动,这样就增加了开发时间和维护成本。

四、多态

        多态: 都是同一个类型,调用同一个方法,却能呈现不同的状态。

1.操作符的多态

        同一个操作符在不同情境下,具备不同的作用
        如果+号两侧都是整型,那么+代表 数字相加
        如果+号两侧,任意一个是字符串,那么+代表字符串连接

2.类的多态条件

        要实现类的多态,需要如下条件

        1. 父类(接口)引用指向子类对象

        2. 调用的方法有重写

五、隐藏

        与重写类似,方法的重写是子类覆盖父类的对象方法;隐藏,就是子类覆盖父类的类方法。

        类方法就是静态方法。

六、super关键字

1.实例化子类,父类的构造方法一定会被调用

        实例化一个ADHero(), 其构造方法会被调用
        其父类的构造方法也会被调用
        并且是父类构造方法先调用
        子类构造方法会默认调用父类的无参的构造方法

 2.super的用法和this很像,super是调用父类的方方法,而this是调用自己的。        

七、final修饰符

1.final修饰的类不能被继承;

2.inal修饰的方法不能被重写;

3.final修饰基本类型变量,表示该变量只有一次赋值机会;

        常量指的是可以公开,直接访问,不会变化的值

4.final修饰引用,表示该引用只有1次指向对象的机会。

八、object类

        Object类是所有类的父类,声明一个类的时候,默认是继承了Object。

1.toString()

        Object类提供一个toString方法,所以所有的类都有toString方法,toString()的意思是返回当前对象的字符串表达。

2.finalize()

        当一个对象没有任何引用指向的时候,它就满足垃圾回收的条件。当它被垃圾回收的时候,它的finalize() 方法就会被调用。

3. equals()

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

4.==

        这不是Object的方法,但是用于判断两个对象是否相同。更准确的讲,用于判断两个引用,是否指向了同一个对象。

5.hashCode()

        hashCode方法返回一个对象的哈希值。

6.Object还提供线程同步相关方法

7.getClass()

        getClass()会返回一个对象的类对象。

九、抽象类

1.抽象类

        在类中声明一个方法,这个方法没有实现体,是一个“空”方法;
        这样的方法就叫抽象方法,使用修饰符“abstract";
        当一个类有抽象方法的时候,该类必须被声明为抽象类。

public abstract class Hero { 
    // 抽象方法attack
    // Hero的子类会被要求实现attack方法
    public abstract void attack();
 
}

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

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

2.抽象类和接口的区别

(1)区别1:
        子类只能继承一个抽象类,不能继承多个
        子类可以实现多个接口
(2)区别2:
        抽象类可以定义:public,protected,package,private、静态和非静态属性、final和非final属性
        但是接口中声明的属性,只能是:public、静态、final的,即便没有显式的声明

        注: 抽象类和接口都可以有实体方法。 接口中的实体方法,叫做默认方法。

3.默认方法

        默认方法是JDK8新特性,指的是接口也可以提供具体方法了,而不像以前,只能提供抽象方法。例如Mortal 这个接口,增加了一个默认方法 revive,这个方法有实现体,并且被声明为了default。

interface Mortal {
	public void die();
	default public void revive() {
		System.out.println("本英雄复活了");
	}
}

        假设没有默认方法这种机制,那么如果要为Mortal增加一个新的方法revive,那么所有实现了Mortal接口的类,都需要做改动。
        但是引入了默认方法后,原来的类,不需要做任何改动,并且还能得到这个默认方法。
        通过这种手段,就能够很好的扩展新的类,并且做到不影响原来的类。

十、内部类

1.非静态内部类

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

        语法: new 外部类().new 内部类()。

        作为非静态内部类,是可以直接访问外部类的private实例属性的。

class Hero {
	private String name; // 姓名

	// 非静态内部类,只有一个外部类对象存在的时候,才有意义
	// 战斗成绩只有在一个英雄对象存在的时候才有意义
	class BattleScore {
		int kill;
		int die;
		int assit;

		public void legendary() {
			if (kill >= 8)
				System.out.println(name + "超神!");
			else
				System.out.println(name + "尚未超神!");
		}
	}
}	

public class MAIN {
    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 外部类.静态内部类();
        因为没有一个外部类的实例,所以在静态内部类里面不可以访问外部类的实例属性和方法;
        除了可以访问外部类的私有静态成员外,静态内部类和普通类没什么大的区别。

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

public class MAIN {
    public static void main(String[] args) {
        //实例化静态内部类
        Hero.EnemyCrystal crystal = new Hero.EnemyCrystal();
        crystal.checkIfVictory();
    }
}

3.匿名类

        匿名类指的是在声明一个类的同时实例化它,使代码更加简洁精练;
        通常情况下,要使用一个接口或者抽象类,都必须创建一个子类;
        有的时候,为了快速使用,直接实例化一个抽象类,并“当场”实现其抽象方法。既然实现了抽象方法,那么就是一个新的类,只是这个类,没有命名。 这样的类,叫做匿名类。

abstract class Hero {
    String name; //姓名          
    float hp; //血量          
    float armor; //护甲          
    int moveSpeed; //移动速度
      
    public abstract void attack();
}
public abstract class Hero {
    public static void main(String[] args) {                   
        Hero h = new Hero(){
            //当场实现attack方法
            public void attack() {
                System.out.println("新的进攻手段");
            }
        };
        h.attack();         
        System.out.println(h);
    }
}

        在匿名类中使用外部的局部变量,外部的局部变量必须修饰为final。
        注:在jdk8中,已经不需要强制修饰成final了,如果没有写final,不会报错,因为编译器偷偷的帮你加上了看不见的final。

4.本地类

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

abstract class Hero {
    String name; //姓名          
    float hp; //血量          
    float armor; //护甲          
    int moveSpeed; //移动速度
      
    public abstract void attack();
}
public abstract class Hero {
    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();
    }
}
这篇关于JAVA学习笔记(第五章 接口与继承)的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!