漫漫Java学习路,第八天

最新推荐文章于 2025-12-10 21:25:44 发布

原创最新推荐文章于 2025-12-10 21:25:44 发布 · 111 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言 #后端

本文通过实例讲解了Java中的继承、重写方法及final特性，包括如何创建继承关系、方法覆盖规则和final类与方法的应用。还探讨了静态方法和静态代码块，以及多态的概念和使用场景。

package cn.tedu.oop;
//本类用于测试继承中普通方法的使用
public class TestExtends {
    public static void main(String[] args) {
        Father f = new Father();
        Son s = new Son();
        f.eat();
        s.eat();
        f.play();
        s.play();
    }
}
class Father{
    public void eat(){
        System.out.println("爸爸爱吃肉");
    }
    public void play(){
        System.out.println("爸爸爱放风筝");
    }
}
class Son extends Father{
    /*如果子类对父类的方法实现不满意,可以在子类中重写父类的方法的
    * 重写的语法规则:两同 两小 一大
    * 两同:子类方法的 方法名与参数列表 和父类方法相同
    * 一大:子类方法的 修饰符权限>=父类方法的修饰符权限
    * 两小:子类方法的返回值类型与父类方法的返回值类型相同,或者是父类方法返回值类型的子类
    * 注意:如果父类方法的返回值类型为void,子类应该保持一致*/
    @Override//注解,标记这是一个重写的方法
    public void eat(){
        System.out.println("儿子爱吃菠菜");
    }
    public void play(){
        System.out.println("儿子爱坑爹");
    }
}

package cn.tedu.oop;
//本类用于测试关键字final
public class TestFinal {

}
/*1.final可以用来修饰类,被final修饰的类是最终类,不可以被继承
* 可以吧final修饰的类看成树结构中的叶子节点*/
//final class Father2{
class Father2{
    /*final可以用来修饰方法,被final修饰的方法是这个方法的最终实现,不可以被重写*/
    //public final void work(){
    public void work(){
        System.out.println("在工厂里上班");
    }
}
class Son2 extends Father2{
    public void work(){
        System.out.println("在电子厂上班");
        /*被final修饰的是常量,常量的值不可以被修改
        * 注意:不管是成员位置还是局部位置,常量定义的时候必须赋值
        * 注意:常量的名称必须是全大写,单词与单词之间使用_分割*/
        final int B = 100;//常量的值不允许修改,一旦声明后就无法再次赋值
        //B = 200;
    }
}

package cn.tedu.oop;
/*拓展:方法重写之返回值类型
* 1.如果父类的方法的返回值类型与子类方法的返回值类型一样,肯定没错
* 2.如果父类方法的返回值类型为:8大基本类型/String/void,子类重写时应该保持一致
* 3.如果父类方法的返回值类型是其他引用类型,子类方法:父类返回值类型的子类/两者相同*/
public class TestMethod {
    public static void main(String[] args) {

    }
}
class Fu{
    public int eat(){
        return 666;
    }
    public String play(){
        return "中午好";
    }
    public Animal clean(){
        Animal a = new Animal();
        return a;
    }
}
class Zi extends Fu{
    public int eat(){
        return 995;
    }
    public String play(){
        return "下午好";
    }
    public Cat clean() {
        Cat C = new Cat();
        return C;
    }
}
class Animal{

}
class Cat extends Animal{

}

package cn.tedu.oop2;

public class TestExtends {
    public static void main(String[] args) {
        Animal a = new Animal();
        Cat c = new Cat();
        Dog d = new Dog();
        a.eat();
        System.out.println(a.show());
        c.eat();
        System.out.println(c.show());
        d.eat();
        System.out.println(d.show());
        int aaa = a.sum();
        System.out.println(aaa);
        System.out.println(aaa+10);
    }
}
class Animal{
    public int sum(){
        return 5;
    }
    public void eat(){
        System.out.println("小动物Animal见啥吃啥");
    }
    public Animal show(){
        System.out.println("我是一只小动物");
        Animal a = new Animal();
        return a;
    }
}
class Cat extends Animal{
    public void eat(){
        System.out.println("小猫爱吃小鱼干");
    }
    public Animal show(){
        System.out.println("我是一只小猫咪");
        Cat c = new Cat();
        return c;
    }
}
class Dog extends Animal{
    public void eat(){
        System.out.println("小狗爱吃肉骨头");
    }
    public Dog show(){
        System.out.println("我是一只哈士奇");
        Dog d = new Dog();
        return d;
    }
}

package cn.tedu.oop2;
//本类用作静态static的入门案例
/*0.被static修饰的资源统称为静态资源
* 静态资源是随着类加载而加载到内存中的,比对象优先进入内存
* 所有,静态资源可以不通过对象,直接通过类名调用*/
public class TestStatic1 {
    public static void main(String[] args) {
        Fruit f1 = new Fruit();
        System.out.println(Fruit.kind);
        System.out.println(Fruit.weight);
        Fruit.clean();
        f1.grow();//不静态,可以使用对象直接点出来
        Fruit f2 = new Fruit();
        f1.prize = 6.6;
        System.out.println(f1.prize);
        System.out.println(f2.prize);
        /*静态资源在内存中只有一份,而且会被全局所有对象共享
        * 所有:不管我们使用那种方式修改了静态变量的值,使用任何方式来查看
        * 都是静态变量那个刚刚被修改了的值*/
        Fruit.kind = "苹果";
        System.out.println(Fruit.kind);
        System.out.println(f1.kind);
        System.out.println(f2.kind);
        f1.kind = "猕猴桃";
        System.out.println(Fruit.kind);
        System.out.println(f1.kind);
        System.out.println(f2.kind);
        f2.kind = "橘子";
        System.out.println(Fruit.kind);
        System.out.println(f1.kind);
        System.out.println(f2.kind);
    }
}
class Fruit{
    //1.static可以用来修饰成员变量吗?-->可以!
    static String kind;
    static double weight;
    final int a = 546;
    double prize;

    //2.static可以用来修饰成员方法吗?-->可以!
    public static void clean(){
        System.out.println("洗刷刷洗刷刷");
    }
    public void grow(){
        System.out.println("这果子一看就有毒");
    }
}

package cn.tedu.oop2;
/*本类用于测试静态的调用关系
* 总结:
* 1.普通资源既可以调用普通资源,又可以调用静态资源
* 2.静态资源只能调用静态资源*/
public class TestStatic2 {

}
class Teacher{
    String name;
    public void teach(){
        System.out.println("何人在此喧哗!");
        /*1.普通资源能否调用静态资源?-->可以!*/
        System.out.println(age);
        ready();
    }
    static int age;
    public static void ready(){
        System.out.println("尔等竟敢咆哮公堂!!!");
        /*2.静态资源能否调用普通资源?-->不可以!*/
        //System.out.println(name);
        //teach();
    }
    public static void eat(){
        System.out.println("正在蓄力.....");
        /*3.静态资源能否调用静态资源?-->可以!*/
        System.out.println(age);
        ready();
    }
}

package cn.tedu.oop2;
//本类用于测试静态代码块
public class TestStatic3 {
    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person();
        p1.play();
    }
}
class Person{
    /*静态代码块:static{}
    * 1.位置:类里方法外
    * 2.执行时机:静态代码块也属于静态资源,随着类的加载而加载,优先于对象加载,
    *           并且静态资源只需要加载一次
    * 3.作用:用于加载那些需要第一时间就加载,并且只加载一次的资源,常用来初始化
    * 执行顺序:
    * 静态代码块-->构造代码块-->构造方法[对象创建成功]-->普通方法-->局部代码块*/
    static{
        System.out.println("吃葡萄不吐葡萄皮,不吃葡萄倒吐葡萄皮");
    }
    /*构造代码块
    * 1.位置:类里方法外
    * 2.执行时机:创建对象时执行,并且优于构造方法执行
    * 3.作用:用于提取所有构造方法的共性功能*/
    {
        System.out.println("红鲤鱼与绿鲤鱼与驴");
    }
    public Person(){
        System.out.println("小皮鞭沾凉水");
    }
    public void play(){
        System.out.println("不听不听王八念经");
        /*局部代码块
        * 1.位置:方法里
        * 2.执行时机:当局部代码块所处的方法被调用时才会执行
        * 3.作用:用于限制变量的作用范围*/
        {
            System.out.println("不看不看乌龟下蛋");
        }
    }
}

package cn.tedu.oop3;
//本类用作多台的入门案例
public class TestDemo {
    public static void main(String[] args) {
        Animal a = new Animal();
        Cat c = new Cat();
        Dog d = new Dog();
        a.eat();
        c.eat();
        d.eat();
        /*2.父类对象不可以使用子类的特有功能*/
        //a.jump();//报错,父类里没有这个功能
        //a.run();
        c.jump();
        d.run();
        /*3.口诀1:父类引用指向子类对象
        * 解释:创建出来的子类对象的地址值,交给父类类型的引用类型变量来保存*/
        Animal a2 = new Cat();
        Animal a3 = new Dog();
        /*口诀2:编译看左边,运行看右边
        * 解释:必须要在父类中定义这个方法,才能通过编译,把多态对象看做是父类类型
        *      必须要在子类中重写这个方法,才能满足多态,实际干活的是子类*/
        a2.eat();//多态对象使用的是父类的定义,子类的方法
        a3.eat();
    }
}
/*1.多肽的前提:继承+重写*/
class Animal{
    public void eat(){
        System.out.println("弱肉强食");
    }
}
class Cat extends Animal{
    public void eat(){
        System.out.println("老鼠克星");
    }
    public void jump(){
        System.out.println("三天不打上房揭瓦");
    }
}
class Dog extends Animal{
    public void eat() {
        System.out.println("荤素不忌");
    }
    public void run(){
        System.out.println("撒手没");
    }
}