接口与继承(3)

接口与继承(3)

1.Object类
Object是所有类的父类，声明一个类的时候，默认是继承了Object
1.1toString()，finalize()，equals()，==
toString()的意思是返回当前对象的字符串表达
通过 System.out.println 打印对象就是打印该对象的toString()返回值

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

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

package pack3;



public class Hero {
    String name;
    //重写finalize方法
    public void finalize(){
        System.out.println("这个对象正在被回收");
    }
//重写equals方法
public boolean equals(Object o){
    if(o instanceof Hero){
        Hero h = (Hero) o;
        return this.name == h.name;
    }
    return false;
}

    public static void main(String args[]){
        //toString()打印对象的字符串
        Hero hero=new Hero();
        System.out.println(hero.toString());

        //finalize()回收对象
        Hero h;
        for(int i=1;i<=600000;i++)
            h=new Hero();
        //equals()方法
        Hero hero1=new Hero();
        Hero hero2=new Hero();
        hero2.name="yzs";
        hero1.name="yzs";
        System.out.println("equals:"+hero2.equals(hero1));
        //==
        System.out.println(hero1==hero2);

    }

}

运行结果


2.final关键字
2.1final修饰类
当父类被修饰成final的时候，表示父类不能够被继承
2.2final修饰基本类型变量
final修饰基本类型变量，表示该变量只有一次赋值机会

package pack3;

public class TEST {
    public static void main(String args[]){
        final int a=1;
        a=2;//错误,只能被赋值一次
    }
}

2.3final修饰引用

package pack3;

public class TEST {

    TEST(){}
    public static void main(String args[]){
    final TEST test;
    test=new TEST();//引用TEST只有一次指向对象的机会
    test=new TEST();

//        final int a=1;
//        a=2;//错误,只能被赋值一次
    }

2.4final修饰方法
父类的方法如果用final修饰 子类不能重写

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

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

3.1 抽象类

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

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

package pack3;
public abstract class  Hero {
    
//抽象类可以没有抽象方法 抽象方法一定在抽象类中

    public static void main(String args[]){
        Hero h=new Hero() ;//错误 不能直接实例化

    }
 }  

3.3 抽象类与接口的区别

4.内部类
4.1 非静态内部类
非静态内部类 BattleScore “战斗成绩”
非静态内部类可以直接在一个类里面定义

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

package pack4;

public class Hero {
    private String name;//姓名

    //非静态内部类 只有一个外部类对象存在的时候 才有意义
    //战斗成绩只有在一个英雄存在的时候才有意义

    class BattleScore{
        int kill;
        int die;
        int assit;
        public void legendary(){ //legendary--传奇
         if(kill>=8)System.out.println(name+"超神");
         else System.out.println(name+"未超神");
        }
    }

    public  static void main(String args[]){
        Hero luluxiu=new Hero();
        luluxiu.name="鲁鲁修";
        BattleScore score=luluxiu.new BattleScore();
        score.kill=9;
        score.legendary();
    }
}

4.2静态内部类
在一个类里面声明一个静态内部类
比如敌方水晶，当敌方水晶没有血的时候，己方所有英雄都取得胜利，而不只是某一个具体的英雄取得胜利。
与非静态内部类不同，静态内部类水晶类的实例化 不需要一个外部类的实例为基础，可以直接实例化
语法：new 外部类.静态内部类();
因为没有一个外部类的实例，所以在静态内部类里面不可以访问外部类的实例属性和方法
除了可以访问外部类的私有静态成员外，静态内部类和普通类没什么大的区别
4.3 匿名类
匿名类指的是在声明一个类的同时实例化它，使代码更加简洁精练
通常情况下，要使用一个接口或者抽象类，都必须创建一个子类

有的时候，为了快速使用，直接实例化一个抽象类，并“当场”实现其抽象方法。
既然实现了抽象方法，那么就是一个新的类，只是这个类，没有命名。
这样的类，叫做匿名类

package pack4;

public abstract class Hero {
    private String name;//姓名
    public abstract void attack();
    public  static void main(String args[]){
    //这是一个新的类 但是这个类没有名字
        Hero hero=new Hero() {
            @Override
            public void attack() {
                System.out.println("普通英雄attack");
            }
        };

        hero.attack();
     }
  }      

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

package pack4;

public abstract class Hero {
     String name;//姓名
    public abstract void attack();

public static void main(String args[]){
//继承Hero类
    class magicHero extends Hero{
        public void attack(){
            System.out.println("magic attack");
        }
    }
//新的名字magicHero
    magicHero magicHero=new magicHero();
    magicHero.name="魔法Hero";

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

package pack4;

public interface Mortal {
    
    //默认方法 加关键字default
    default public void revive(){
        System.out.println("复活");
    }
}

问题:有多个接口,接口实现了同样的默认方法,实现接口的子类要调用的是哪个接口的默认方法?
回答:如果是实现多个接口同时这些接口中都实现了同样的默认方法,那么实现的子类必须要实现这个默认方法-因为不知道要选择哪个方法而只要默认方法只有一个那么就可以不用实现。