Java零基础入门到精通_Day 12

已于 2024-05-04 13:08:15 修改
阅读量179 收藏 1
点赞数 3
分类专栏： Java 文章标签： java 开发语言
于 2024-05-02 23:08:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48690722/article/details/138398964
版权

1.多态

package Base_se.Base_012.b01;

public class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
}

package Base_se.Base_012.b01;

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}


package Base_se.Base_012.b01;

public class AnimalDemo {
    public static void main(String[] args) {
        // 有父类引用指向子类对象
        Animal a = new Cat();
    }
}

2.多态中成员访问特点

package Base_se.Base_012.b02;

public class Animal {
    public int age =40;
    public void eat() {
        System.out.println("动物吃东西");
    }
}

package Base_se.Base_012.b02;

public class Cat extends Animal {
    public int age = 20;
    public int weight = 10;
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void play() {
        System.out.println("玩游戏");
    }
}

package Base_se.Base_012.b02;

public class AnimalDemo {
    public static void main(String[] args) {
        // 有父类引用指向子类对象
        Animal a = new Cat();

        // 访问成员变量：编译和运行都要看左边的
        System.out.println(a.age); //40
//        System.out.println(a.weight);
        // 访问成员方法 编译左边 运行右边
        a.eat();
//        a.play();
    }
}

3.多态的利弊

package Base_se.Base_012.b03;

public class Animal {

    public void eat() {
        System.out.println("动物吃东西");
    }
}


package Base_se.Base_012.b03;


public class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

}

package Base_se.Base_012.b03;

public class Pig extends Animal{
    @Override
    public void eat() {
        System.out.println("猪");
    }
}

package Base_se.Base_012.b03;

public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗");
    }
    public void Look(){
        System.out.println("看");
    }
}


package Base_se.Base_012.b03;

public class AnimalOpti {
//    public void useAnimal(Cat c){
//        c.eat();
//    }
//
//    public void useAnimal(Dog d){
//        d.eat();
//    }
    public void useAnimal(Animal a){
//        Animal a = new Cat();
//        Animal a = new Cat();
        a.eat();
//        a.look(); 不能访问的子类的特有方法
    }
}

package Base_se.Base_012.b03;


public class AnimalDemo {
    public static void main(String[] args) {
        // 创建动物操作类的对象，调用方法
        AnimalOpti ao = new AnimalOpti();
        Cat cat = new Cat();
        ao.useAnimal(cat);

        Dog d = new Dog();
        ao.useAnimal(d);

        Pig pig = new Pig();
        ao.useAnimal(pig);

    }
}

4.多态中的转型

package Base_se.Base_012.b04;

public class Animal {
    public void ext(){
        System.out.println("动物吃东西");
    }
}


package Base_se.Base_012.b04;

public class Cat extends Animal{
    @Override
    public void ext(){
        System.out.println("猫吃鱼");
    }

    public void play(){
        System.out.println("玩耍");
    }

}


package Base_se.Base_012.b04;

public class AnimalDemo {
    /*
    * 向上转型:从子到父 父类引用指向子类对象
      向下转型:从父到子 父类引用转为子类对象
    * */
    public static void main(String[] args) {
        // 多态
        Animal a = new Cat(); // 向上转型
        a.ext();
//        a.play();

//        Cat cat = new Cat();
//        cat.ext();
//        cat.play();
        // 向下转型

        Cat c = (Cat) a; //强制转换为Cat 类型的
        c.ext();
        c.play();

    }
}

5.多态内存图解

6.案例

package Base_se.Base_012.b05;

public class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void eat(){
        System.out.println("动物吃东西");
    }
}



package Base_se.Base_012.b05;

public class Cat extends Animal{
    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("猫");
    }
}



package Base_se.Base_012.b05;

public class AnimalDemo {
    public static void main(String[] args) {
        // 创建猫类对象
        Animal a = new Cat();
        a.setName("加菲");
        a.setAge(12);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();

        a = new Cat("加菲",13);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();


    }
}

7.抽象类

package Base_se.Base_012.b006;

public abstract class Animal {
    //    public void eat(){
//        System.out.println("吃东西");
//    }
    // 抽象方法
    // 抽象方法必须是抽象类 抽象类可以没有抽象方法 但是没什么意义
    public abstract void eat();

    public void sleep() {
        System.out.println("睡觉");
    }
    
}


package Base_se.Base_012.b006;

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫");
    }
}

package Base_se.Base_012.b006;

public  class Dog extends Animal{

    @Override
    public void eat(){
        System.out.println(111);
    }
}

package Base_se.Base_012.b006;

public class AnimalDemo {
    public static void main(String[] args) {
        Animal a = new Cat();
        a.eat();
        a.sleep();

        Animal d = new Dog();
        d.eat();
    }

}

8.抽象类的成员特点

package Base_se.Base_012.b07;

import javax.swing.*;

public abstract class Animal {
    private int age = 20;
    private final String city = "北京";

    public Animal(int age) {
        this.age = age;
    }

    public Animal() {
    }

    public void show() {
        age = 40;
        System.out.println(age);
        System.out.println(city);
    }

    public abstract void eat();


}


package Base_se.Base_012.b07;

public class Cat extends Animal{
    @Override
    public void eat(){
        System.out.println("猫");
    }

}


package Base_se.Base_012.b07;

public class AnimalDemo {
    public static void main(String[] args) {
        Animal a = new Cat();
        a.eat();
        a.show();
    }
}

9.猫和狗（抽象类版本）

package Base_se.Base_012.b08;

public abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public abstract void eat();
}

package Base_se.Base_012.b08;

public class Cat extends Animal {

    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }
    @Override
    public  void eat(){
        System.out.println("猫");
    }

}

package Base_se.Base_012.b08;

public class Dog extends Animal {
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println("狗");
    }

}


package Base_se.Base_012.b08;

public class AnimalDemo{
    public static void main(String[] args) {
        Animal a = new Cat();
        a.setName("猫1");
        a.setAge(1);
        System.out.println(a.getName()+","+a.getAge());

        a = new Cat("mao2",11);
        System.out.println(a.getName()+","+a.getAge());
    }
}

10.接口

11.接口特点

package Base_se.Base_012.b09;

public interface Jumpping {
    public abstract void jump();
}

package Base_se.Base_012.b09;

public class Cat implements Jumpping {
    @Override
    public void jump() {
        System.out.println("猫");
    }
}


package Base_se.Base_012.b09;

public abstract class Dog implements Jumpping{
    // 此处必须重写接口中的方法
    //或者变为抽象类
    //Dog的子类以后继承DOg 还要重写Jumpping里面的方法
}


package Base_se.Base_012.b09;

public class JumppingDemo {
    public static void main(String[] args) {
//        Jumpping j = new Jumpping();
        Jumpping j = new Cat();

        j.jump();
    }
}

12.接口成员特点

package Base_se.Base_012.b10;

public interface Inter {
    public int num =10;
    public  final int n2 = 20;
    public static final int n3 = 20;
    // 都是常量 等价于int n3 = 20;

    //接口里面无构造方法 主要是对行为的抽象
    // 接口里面的成员方法只能是抽象的
    public abstract void show();
    void method();

}

package Base_se.Base_012.b10;

public class Interlmpl extends Object implements Inter{
    public Interlmpl() {
        super();
    }
    @Override
    public void show(){
        System.out.println("1");
    }
    @Override
    public void method(){
        System.out.println("2");
    }
}


package Base_se.Base_012.b10;

public class InterfaceDemo {
    public static void main(String[] args) {
        Inter i = new Interlmpl();
//        i.num = 111;
        System.out.println(i.num);
//        i.n2 = 222;
        System.out.println(i.n2);
        System.out.println(Inter.num);
        i.show();
        i.method();
    }
}

13.猫和狗接口版本

package Base_se.Base_012.b11;

public interface Jumpping {
    public abstract void jump();
}

package Base_se.Base_012.b11;

public abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public abstract void eat();
}


package Base_se.Base_012.b11;

public class Cat extends Animal implements Jumpping {
    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void jump() {
        System.out.println("猫调高");
    }

    @Override
    public void eat() {
        System.out.println("猫吃饭");
    }


}


package Base_se.Base_012.b11;

public class AnimalDemo {
    public static void main(String[] args) {
        Jumpping j = new Cat();
        j.jump();

        Animal a = new Cat();
        a.setName("加菲");
        a.setAge(12);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
        ((Cat) a).jump();

        a = new Cat("加加",1);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();

        Cat c = new Cat();
        c.setName("加菲");
        c.setAge(12);
        System.out.println(c.getName()+","+c.getAge());
        c.eat();
        c.jump();

    }
}

14. 类和接口的关系

15.抽象类和接口的区别

举个例子 说明他们的区别：

如果我们想增加报警的方法，那么该放在那个地方呢 都给都放在抽象类和接口中 那么我们在进行实例化的时候 必须全部重写接口或者类中的方法 但是有的类却不能实现其他的方法 比如开关门 

我们这样做：

这样这样：

16.案例

package Base_se.Base_012.b13;

public interface English {
    public abstract void speak_english();
}

package Base_se.Base_012.b13;

public abstract class People {
    private String name;
    private int age;

    public People() {
    }

    public People(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    // 抽象的eat方法
    public abstract void eat();
}

package Base_se.Base_012.b13;

public abstract class Teach extends People{
    public Teach() {
    }

    public Teach(String name, int age) {
        super(name, age);
    }

    public abstract void teach();
}

package Base_se.Base_012.b13;

public abstract class Sporter extends People{
    public Sporter() {
    }

    public Sporter(String name, int age) {
        super(name, age);
    }

    public abstract void study();
}

package Base_se.Base_012.b13;

public class basket_teach extends Teach{
    public basket_teach() {
    }

    public basket_teach(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat(){
        System.out.println("篮球教练吃饭");
    }
    @Override
    public void teach(){
        System.out.println("篮球教练教学");
    }

}

package Base_se.Base_012.b13;

public class Ping_teach extends Teach implements English{
    public Ping_teach() {
    }

    public Ping_teach(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat(){
        System.out.println("乒乓球教练吃饭");
    }
    @Override
    public void teach(){
        System.out.println("乒乓球教练教学");
    }
    @Override
    public void speak_english(){
        System.out.println("乒乓球学习英语");
    }

}

package Base_se.Base_012.b13;

public class Basket extends Sporter{
    public Basket() {
    }

    public Basket(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat(){
        System.out.println("篮球运动员吃饭");
    }
    @Override
    public void study(){
        System.out.println("篮球运动员学习");
    }
}

package Base_se.Base_012.b13;

public class Ping extends Sporter implements English{
    public Ping() {
    }

    public Ping(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat(){
        System.out.println("乒乓球运动员吃饭");
    }
    @Override
    public void study(){
        System.out.println("乒乓球运动员学习");
    }
    @Override
    public void speak_english(){
        System.out.println("乒乓球运动员学英语");
    }

}

package Base_se.Base_012.b13;

public class Demo {
    public static void main(String[] args) {
        Ping p = new Ping();
        p.setName("甲");
        p.setAge(12);
        p.eat();
        p.study();
        p.speak_english();
        System.out.println(p.getName() + "," + p.getAge());
        System.out.println();

        Basket b = new Basket("乙", 22);
        b.eat();
        b.study();
//        b.speak_english();
        System.out.println(p.getName() + "," + p.getAge());


    }
}

XF鸭
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
零基础Java入门编程【day7】
01-20
文章目录继承与多态继承单继承方法的重写super关键字调用父类的构造器super和this的区别简单类对象的实例化过程子类对象...Java 中的继承就是在已经存在类的基础上进行扩展，从而产生新的类。已经存在的类称为父类、基
Java入门基础学习资料day11
10-22
此java基础课程，适合0基础小白，课程一共11天课时，目录如下： day01【前言、入门程序、常量、变量】 day02【数据类型转换、运算符、方法入门】 day03【流程控制语句】 day04【 Idea、方法】 day05【数组】 day06...
Java零基础入门到精通_Day 1
XF的博客
03-11 499
Java语言是美国Sun公司(StanfordUniversity Network)在1995年推出的计算机语言Java之父:詹姆斯·高斯林(ames Gosling)重要的版本过度：2004年 Java 5.02014年 Java 8.02018年 9月 Java 11.0 （目前所使用的）
Java零基础入门到精通_Day 8
XF的博客
04-28 355
应用程序接口Java API:指的就是JDK 中提供的各种功能的Java类这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用。
Java零基础入门到精通_Day 9
XF的博客
05-02 331
编程的时候如果要存储多个数据，使用长度固定的数组存储格式，不一定满足我们的需求，更适应不了变化的需求，那么，此时该如何选择呢?集 合集合类的特点:提供一种存储空间可变的存储模型，存储的数据容量可以发生改变集合类有很多，目前我们先学习一个:ArrayList。
Java零基础入门到精通_Day 11
XF的博客
05-02 167
定义：继承是面向对象三大特征之一。可以使得子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法子类：也叫派生类父类：基类/超类继承中子类的特点:子类可以有父类的内容子类还可以有自己特有的内容。
Java零基础入门到精通_Day 6
XF的博客
04-07 277
【代码】Java零基础入门到精通_Day 5。
Java零基础入门到精通_Day 7
XF的博客
04-19 166
类是什么:是对现实生活中一类具有共同属性和行为的事物的抽象，确定对象将会拥有的属性和行为。提供相应的操作提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰。属性:对象具有的各种特征，每个对象的每个属性都拥有特定的值。类:类是对现实生活中一类具有共同属性和行为的事物的抽象。类是对现实生活中一类具有共同属性和行为的事物的抽象。属性: 在类中通过成员变量来体现(类中方法外的变量)类的重要性:是Java程序的基本组成单位。类是具有相同属性和行为的一组对象的集合。1.4 什么是对象的属性。
Java零基础入门到精通_Day 4
XF的博客
04-02 88
好像就是分类内存的知识 数组的定义 初始化 遍历 求最大值最小值的问题。
Java零基础入门到精通_Day 5
XF的博客
04-03 224
就是同一个类中的相同方法名的多个方法，但是他们的参数不同，类型不同或者参数个数不同。（与返回值无关）
Java零基础入门到精通_Day 2
XF的博客
03-26 348
- * / % 整数的运算只能得到整数 除非用浮点数进行运算（得到浮点数）
python从入门到精通（DAY 1）
09-21
本文是此次python从入门到精通系列文章的第一篇，给大家汇总一下常用的Python的基础知识，非常的简单，但是很全面，有需要的小伙伴可以参考下
Java入门基础学习资料day09-10
10-22
此java基础课程，适合0基础小白，课程一共11天课时，目录如下： day01【前言、入门程序、常量、变量】 day02【数据类型转换、运算符、方法入门】 day03【流程控制语句】 day04【 Idea、方法】 day05【数组】 day06...
Java入门基础学习资料day07-08
10-22
此java基础课程，适合0基础小白，课程一共11天课时，目录如下： day01【前言、入门程序、常量、变量】 day02【数据类型转换、运算符、方法入门】 day03【流程控制语句】 day04【 Idea、方法】 day05【数组】 day06...
java学习和项目总结
2301_79390585的博客
05-24 676
JRE：JRE是Java 运行时环境，主要包括了两个运行需要的组件：JVM 和 Java 核心类库，如果不进行java开发只想运行就可以只下载JRE。而Java语言，它的代码会先通过javac编译成字节码，再通过jvm将字节码转换成机器码（0和1）执行，即解释运行和编译运行配合使用，所以是混合型。在程序运行之前，通过编译器将源程序编译成机器码可运行的二进制，以后执行这个程序时，就不用再进行编译了。JVM：JVM是java进行编译的虚拟机，是Java 能够跨平台运行的核心。特点：执行速度慢、效率低；
Java高级面试精粹：问题与解答集锦（一）
Layla_c的博客
05-23 1424
答案多态是Java中的一个核心概念，它允许不同类的对象对同一消息做出响应，但具体的行为会根据对象的实际类型而有所不同。重载（Overloading）：当多个方法具有相同的名称，但参数列表不同时，这称为方法重载。编译器根据方法调用时传递的参数类型和数量来确定调用哪个方法。重写（Overriding）：当子类有一个与父类同名、同参数列表的方法时，子类可以提供特定的实现来覆盖父类的方法。运行时，Java虚拟机（JVM）会根据对象的实际类型调用相应的方法，这个过程称为动态绑定或晚期绑定。答案。
JVM学习-执行引擎
丢爸
05-21 1126
当然是否需要启动JIT编译器将字节码直接编译为对应平台的本地机器指令，则需要根据代码被调用。大部分的程序代码转换为物理机的目标代码或虚拟机能执行的指令集之前，都需要经过下图各个步骤。，将其直接编译为对应平台的本地机器指令，以此提升Java程序的执行性能。”，JIT编译器在运行时会针对那些频繁被调用的热点代码做出。Java代码编译是由Java源码编译器来完成，流程图如下。而定，关于那些需要被编译为本地代码的字节码，称为“Java字节码的执行是由JVM执行引擎来完成。
数据访问与Spring Data JPA
最新发布
无远弗届
05-25 510
假设我们要处理一个用户表（users），可以创建一个User@Entity // 标识这是一个实体类 public class User {@Id // 标识这是主键字段 @GeneratedValue(strategy = GenerationType . AUTO) // 主键生成策略 private Long id;// Getter 和 Setter ... }@Entity // 标识这是一个实体类 public class User {
java Calendar.HOUR_OF_DAY
07-12
`Calendar.HOUR_OF_DAY` 是 Java Calendar 类中用于表示一天中的小时数的常量。它代表了一个24小时制的小时值，范围从0到23。 这个常量在 `Calendar` 类中的使用方式如下： ```java Calendar calendar = Calendar.getInstance(); int hourOfDay = calendar.get(Calendar.HOUR_OF_DAY); ``` 上述代码获取了当前时间的小时数，并将其存储在 `hourOfDay` 变量中。 需要注意的是，`Calendar.HOUR_OF_DAY` 是基于本地时区的，所以获取的小时数会随着时区的变化而变化。如果需要处理不同时区的时间，可以使用 `Calendar.setTimeZone()` 方法来设置时区。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

XF鸭

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值