7.7总结

接着上回没有说完的，有关Java面向对象的操作方法还差一点内容，现在给他补全

十：方法的重写

                10.1 重写：子类对父类中提供的方法进行重新定义，子类和父类中的声明完全一致

                也就是方法的覆盖

//创建一个名为Liyuan的类并为他赋值

public class Liyuan {

    public void makecountry()
    {
        System.out.println("李渊想建立一个自己的国家");
    }
}

        

//再创建一个名为Lishimin的类，在其中进行方法的重构
public class Lishimin extends Liyuan{

    public void makecountry(){
    //半盖
         super.makecountry();//super可以调用父类中被重写的方法
         System.out.println("李世民也想建立自己的国家");
     }
    public static void main(String[] args) {
        Lishimin l = new Lishimin();
        l.makecountry();
    }
}

运行结果：

十一：多态

        11.1 定义：同一个对象拥有多种形态

        11.2 作用：把不同的数据类型进行统一

//people

public class people {
    public void feed(animal ani) {
        ani.eat();
    }
}

定义动物执行吃的动作 

//cat

public class cat extends animal {
    public void eat()
    {
        System.out.println("cat eat fish");
    }

    public void catchmouse()
    {
        System.out.println("cat catch mouse");
    }
}

定义一个猫吃鱼的类 

//dog
public class dog extends animal{
    public void eat(){
        System.out.println("dog eat bone");
    }
}

定义一个狗吃骨头的类 

//daxiang

public class daxiang extends animal {

    public void eat()
    {
        System.out.println("dx eat banada");
    }
}

定义一个大象吃香蕉的类 

 让他们全部都继承animal的父类执行吃的动作，dog，cat和daxiang都属于animal，这就是物品的多态

public class cleant {
    public static void main(String[] args) {
        animal ani1 = new cat();
        animal ani2 = new dog();
        animal ani3 = new daxiang();

        people p = new people();

        p.feed(ani1);
        p.feed(ani2);
        p.feed(ani3);

        cat cc=(cat)ani1;
        cc.catchmouse();//向下转型
    }
}

 运行结果：

注意：

        1.把子类的对象赋值给父类的变量 -> 向上转型

        缺点：屏蔽掉子类中持有的方法

        2.把父类的变量转化给子类  -> 向下转型

        向下转型存在风险所以必须使用强制类型转换

        (转换之后的数据类型的变量）

十二：final关键字

        12.1 final修饰的变量不可以被改变（自认为大概类似于c中的const）

可以发现在运行时编译器报错无法分配值。 

        12.2 被final修饰的方法不能被改变

同样被修饰的方法也不能被继承

        12.3 被final修饰的类不可被改编 

十三：抽象        

        13.1    现实中不存在的东西，在Java中只声明不实现

        抽象方法：使用abstract来修饰，不可以用方法体，直接用分号结束。

        抽象类：如果一个类中抽象方法，这个类必须是一个抽象类

//animal

public abstract class animal {//类中如果有抽象方法，那么这个类必须是一个抽象类
    //abstract修饰方法，这个方法就是一个抽象方法，抽象方法没有方法体，直接 ;  结束
    public abstract void eat();

    public abstract void dong();

}

//cat

public class cat extends animal{
    public void eat(){
        System.out.println("猫吃鱼");
    }
    public void dong(){
        System.out.println("猫懒洋洋的动");
    }
}

//client

public class client {
    public static void main(String[] args) {
        cat c=new cat();
        c.eat();
    }
}

 运行结果：

        特点：

                1.抽象类不可以创建对象

                2.抽象类的子类，必须重写父类中的抽象方法，否则，子类也必须是抽象类

             通过抽象类可以强制的要求子类中必须有哪些方法

                抽象类里可以有正常的方法

十四：接口

       14.1 接口实际上是一种特殊的抽象类

       14.2 接口中的所有方法都是抽象方法

        14.3 接口使用interface来声明

//创建一个接口valueable

/**
 * 能继承接口的只能是接口
 * 接口和类只能是实现关系
 */

public interface valueble {//接口使用interface声明，不再属于类。
    //接口中所有方法都是抽象方法可以直接省略掉abstract
    //接口中的所有内容都是公开的，公共的。
    void getMoney();
}

//接口protectable

public interface protectable {
    public void cang();
}

 

//animal

public class animal {
    public void eat()
    {
        System.out.println("eat");
    }
}

//panda

public class panda extends animal implements valueble,protectable {
    @Override
    public void eat() {
        System.out.println("熊猫吃竹子");
    }

    @Override
    public void cang() {
        System.out.println("藏在山里");
    }

    @Override
    public void getMoney() {
        System.out.println("可以换钱");
    }
}

 

//Test

public class Test {
    public static void main(String[] args) {
        panda panda = new panda();

        panda.eat();
        panda.cang();
        panda.getMoney();
    }
}

运行结果：

 

        类只能单项继承,接口实现多实现

                

        接口同样具有多态性

可以继承animals但是其他就报错

//Test

public class Test {
    public static void main(String[] args) {
        animal panda = new panda();

        panda.eat();
//        panda.cang();
//        panda.getMoney();
    }
}

 

        接口可以把很多不相关的关联一起

      特点：

        1.接口中所有方法都是抽象方法

        2.接口中所有变量都是静态变量