java-1 接口与继承-1

1.创建一个接口 File->New->Interface

创建一个接口AD

public interface AD {
    public void physicAttack();
}

实现某个接口，就相当于承诺了某种约定所以实现一个接口就必须提供接口中的方法

接口语法实现关键字implemwnts

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

一个类可以同时多个接口

public class ADAPHero implements AD,AP{

}

2.重写：子类可以继承父类的对象方法 

在继承后，重复提供该方法，就叫做方法的重写 

又叫覆盖 override

调用时调用重写的方法
调用就会执行重写的方法，而不是从父类的方法

3.多态：

1.操作符多态

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

2.类的多态

当父类调用不同子类中同名方法是可以呈现不同的状态。

类的多态条件

1. 父类（接口）引用指向子类对象
2. 调用的方法有重写

如果物品的种类特别多，那么就需要设计很多的方法
比如useArmor,useWeapon等等

这个时候采用多态来解决这个问题
设计一个方法叫做useItem，其参数类型是Item
如果是使用血瓶，调用该方法
如果是使用魔瓶，还是调用该方法
无论英雄要使用什么样的物品，只需要一个方法即可

package property;
 
public class Item {
    String name;
    int price;
 
    public void buy(){
        System.out.println("p1");
    }
    public void effect() {
        System.out.println("p2 ");
    }
     
    public static void main(String[] args) {
        Item i1= new LifePotion();
        Item i2 = new MagicPotion();
        System.out.print("i1  是Item类型，执行effect打印:");
        i1.effect();
        System.out.print("i2也是Item类型，执行effect打印:");
        i2.effect();
    }
 
}

package property;
 
public class LifePotion extends Item {
    public void effect(){
        System.out.println("qq1");
    }
}

package property;
 
public class MagicPotion extends Item{
 
    public void effect(){
        System.out.println("qq2");
    }
}

package charactor;
 
import property.Item;
import property.LifePotion;
import property.MagicPotion;
   
public class Hero {
    public String name;
    protected float hp;
 
    public void useItem(Item i){
        i.effect();
    }
 
    public static void main(String[] args) {
         
        Hero garen =  new Hero();
        garen.name = "gai";
     
        LifePotion lp =new LifePotion();
        MagicPotion mp =new MagicPotion();
         
        garen.useItem(lp);
        garen.useItem(mp);     
         
    }
       
}

4.隐藏：子类里与父类同名的类方法会隐藏父类的类方法

5.super关键字：对于一个无参个构造方法在实例化时其构造方法会执行一次

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

使用关键字super 可显式调用父类带参的构造方法

父类Hero中

public Hero(String name){
        System.out.println("Hero的有一个参数的构造方法 ");
        this.name = name;
    }

子类ADHero中

public ADHero(String name){
        super(name);
        System.out.println("AD Hero的构造方法");
    }

这样就可以调用父类中带参的构造方法。

调用父类属性

通过super调用父类的moveSpeed属性
ADHero也提供了属性moveSpeed

public int getMoveSpeed(){
   return this.moveSpeed;
}
public int getMoveSpeed2(){
   return super.moveSpeed;
}

package charactor;
  
public class ADHero extends Hero implements AD{
 
    int moveSpeed=400; //移动速度
 
    @Override
    public void physicAttack() {
        System.out.println("进行物理攻击");
    }
     
    public int getMoveSpeed(){
        return this.moveSpeed;
    }
     
    public int getMoveSpeed2(){
        return super.moveSpeed;
    }
     
    public static void main(String[] args) {
        ADHero h= new ADHero();
         
        System.out.println(h.getMoveSpeed());
        System.out.println(h.getMoveSpeed2());
         
    }
  
}

调用父类方法

ADHero重写了useItem方法，并且在useItem中通过super调用父类的useItem方法

package charactor;
 
import property.Item;
import property.LifePotion;
 
public class ADHero extends Hero implements AD {
 
    int moveSpeed = 400; // 移动速度
 
    @Override
    public void physicAttack() {
        System.out.println("进行物理攻击");
    }
 
    public int getMoveSpeed() {
        return this.moveSpeed;
    }
 
    public int getMoveSpeed2() {
        return super.moveSpeed;
    }
 
    // 重写useItem，并在其中调用父类的userItem方法
    public void useItem(Item i) {
        System.out.println("adhero use item");
        super.useItem(i);
    }
 
    public static void main(String[] args) {
        ADHero h = new ADHero();
 
        LifePotion lp = new LifePotion();
 
    }
 
}

6.Object类：Object类是所有类的父类

声明一个类的时候，默认是继承了Object 

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

finalize()当一个对象没有任何引用指向的时候，它就满足垃圾回收的条件

当它被垃圾回收的时候，它的finalize() 方法就会被调用。

finalize() 不是开发人员主动调用的方法，而是由虚拟机JVM调用的。

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

if(o0 instanceof o1)

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

System.out.println(h1==h2);

7.final

final修饰类时，表示这个类不能被继承

public final class q1{
}

final修饰方法时那么在这个类的子类中这个方法不能被重写

final修饰变量时这个变量只能进行一次赋值。

引用被修饰成final，表示该引用只有1次指向对象的机会

8.抽象类

为一个类增加一个抽象方法 attack，并且把这个类声明为abstract的。
其子类继承了它的的属性和方法。
但是各自的攻击手段是不一样的，所以继承Hero类后，这些子类就必须提供不一样的attack方法实现

类可以在不提供抽象方法的前提下，声明为抽象类 
一旦一个类被声明为抽象类，就不能够被直接实例化

抽象类和接口的区别

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

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

注：以上为how2.cn学习笔记，其内容大多来源于其网站