多态 接口 抽象类

最新推荐文章于 2024-04-27 17:50:46 发布
最新推荐文章于 2024-04-27 17:50:46 发布
阅读量140 收藏
点赞数
分类专栏： 就业班 文章标签： day02
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44313232/article/details/86668671
版权

多态：

同一个对象在不同时刻表现出来的不同形态。
前提：

  1. List item存在继承/实现关系
  2. 存在方法重写
  3. 父类引用指向子类对象
    多态中成员访问特点
    使用多态时，访问成员变量的特点：
    编译看左边，运行看左边
    使用多态时，访问成员方法的特点：
    编译看左边，运行看右边
    public class Animal{
public int age=40;
public void eat(){
    System.out.println("动物吃东西");
}
    }
    public static Cat extends Animal{
		oublic int age=20;
		public int weight =10;
		@Override
		public void eat(){
		 System.out.println("猫吃鱼");
		}
		  public void playGame(){
    System.out.println("猫捉迷藏");
    }
}
public class AnimalDemo {
    public static void main(String[] args) {
        //有父类引用指向子类对象
        Animal a = new Cat();
        System.out.println(a.age);
        //System.out.println(a.weight);
        a.eat();
        //a.playGame();
        //成员变量编译执行都看左边，成员方法编译看左边，执行看右边
        //因为成员方法有重写，成员变量没有
    }
}

    public class Animal{
public void eat(){
    System.out.println("动物吃东西" );
    }
}
public  class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
public  class Dog extends Animal{
    public void lookHome(){
        System.out.println("狗看家");
    }
}
 public class AnimalOpeart{
   /*public  void useAnimal(Cat c){
       c.eat();
   }
   public void useAnimal(Dog d){
       d.eat();
   }*/
   //把Animal a 传入这个方法  解决不同子类传入动作类的问题
  public void useAnimal(Animal a){
      a.eat();
  }
}
	public class AnimalDemo{
     public static void main(String[] args) {
          AnimalOpeart ao=new AnimalOpeart();
          Cat c=new Cat();
          ao.useAnimal(c);
          c.eat();

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

    public class Animal {

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

}
public class Cat extends Animal {

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

    public void playGame() {
        System.out.println("猫捉迷藏");
    }
}
public class Dog extends Animal {

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}
public class AnimalDemo {
    public static void main(String[] args) {
        //向上转型
        Animal a = new Cat();
        a.eat();
        //向下转型
        Cat c = (Cat) a;
        c.eat();
        c.playGame();
        //向上转型
        a = new Dog();
        a.eat();
        //向下转型
 //classCastException   类型转换异常
        // Cat cc=(Cat) a;
        // cc.eat();
        //cc.playGame();
    }
}

    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("动物吃东西");
    }
}
public class Cat extends Animal {
    public Cat() {
    }
    public Cat(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
public class Dog extends Animal{
    public Dog() {
    }
    public Dog(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}
public class AnimalDemo {
    public static void main(String[] args) {
        Animal a =new Cat();
        a.setName("加菲猫");
        a.setAge(5);
System.out.println(a.getName()+","+a.getAge());
        a.eat();
        a=new Cat("大花猫",6);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
        System.out.println("--------------");
        Animal d=new Dog();
        d.setName("二哈");
        d.setAge(6);
        System.out.println(d.getName()+","+d.getAge());
       d.eat();
        d=new Dog("大黄",5);        System.out.println(d.getName()+","+d.getAge());
        d.eat();
    }
}

抽象类：

  当父类不知道该方法究竟该干啥，
  就可以把这样的方法定义为抽象方法。
  在java中，一个没有方法体的方法定义为抽象方法
  ，而类中有抽象方法，该类定义为抽象类。
  ```
**特点：**
抽象类必须有abstract关键字修饰。
抽象类不一定有抽象方法，有抽象方法的类一定是                    抽象类。
 抽象的子类：要么重写抽象类中的所有抽象方法。
要么是抽象类。

public  abstract  class Animal{
    //抽象方法
    public  abstract  void eat();
    //抽象方法
    public  void sleep(){
        System.out.println("睡觉");
    }
}
public class Cat extends  Animal{
    //子类继承父类
    // 父类是抽象类所以子类要重写父类所有抽象方法
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
public abstract class Dog extends Animal {
    //抽象类不能被new
  //  子类是个抽象类所以不用重写父类所有抽象方法
}
public class AnimalDemo {
    public static void main(String[] args) {
        Animal a =new Cat();
        //向上转型
        a.eat();
        a.sleep();
    }
}

public abstract class Animal {
    //抽象类
    //成员方法
    private int age = 20;
    private final String city = "北京";
    //构造方法
    public Animal() {
    }

    public Animal(int age) {

        this.age = age;
    }
    //set/get方法
    public int getAge() {

        return age;
    }

    public void setAge(int age) {

        this.age = age;
    }

    public String getCity() {
        return city;
    }
     //定义show方法
    public void show() {
        age = 40;
        System.out.println(age);
        //被final修饰的变量回变成一个常量不能被再次赋值
        // city="上海";
        System.out.println(city);
    }
    //定义一个抽象方法
    public abstract void eat();
}
public class Cat extends Animal{
    //继承抽象父类   重写父类抽象方法
    @Override
    public void eat() {
        
    }
}
public class AnimalDemo {
    public static void main(String[] args) {
        //向上转型 调用方法
        Animal  a=new Cat();
        a.eat();
        a.show();
    }
}

猫狗案例升级版：

public abstract class Animal {
    //定义一个抽象父类
    //定义成员变量
    private String name;
    private int age;
    //构造方法
    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //set/get方法
    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();
}
public class Cat extends Animal{
    //继承父类
    //定义两个构造方法
    public Cat() {
    }
    public Cat(String name, int age) {
        super(name, age);
    }
    //重写抽象方法
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
public class Dog extends Animal{
    //继承父类
    //构造方法
    public Dog() {
    }

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

    //重写抽象方法
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}
public class AnimalDemo {
    public static void main(String[] args) {
        
        Animal a = new Cat();
        //向上转型
        //传入数据
        a.setName("加菲猫");
        a.setAge(6);
        System.out.println(a.getName() + "," + a.getAge());
        //调用eat方法
        a.eat();

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

        Animal d = new Dog();
        d.setName("二哈");
        d.setAge(5);
        System.out.println(d.getName() + "," + d.getAge());
        d.eat();

        d = new Dog("二哈", 5);
        System.out.println(d.getName() + "," + d.getAge());
        d.eat();
    }
}

接口：

接口是一种公共的规范标准，只要符合规范标准，大家都可以用。java中的接口更多的体现在对行为的抽象。
接口的定义格式：
接口用interface修饰
public Interface 接口名{}
类实现接口用implements表示：
public class 类名 implements 接口名{}
接口成员的特点：
成员变量默认被：
public static final修饰。所以成员变量只能是常量。
构造方法：
没有， 因为接口是扩展功能没有具体存在。
成员方法：
只能是抽象方法。
默认修饰符：public abstarct

  1. List item接口不能被实例化，通过类对象实例化，接口多态。
  2. 接口的子类：重写接口中所以抽象方法 要么子类也是抽象类
  3. 一个类可以实现多个接口，接口与接口之间能多继承。
    抽象类和接口的区别:
    抽象类： 对事物的抽象
    接口： 对行为的抽象；
    		public interface Jumpping {
//定义一个接口
//定义一个抽象方法
public abstract void jump();
   }
   public class Cat implements Jumpping {
    //定义了一个类实现接口   重写接口中的所欲抽象方法
    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}
public abstract class Dog implements Jumpping {
    //类实现接口     子类是个抽象类  所欲不用重写接口中所有抽象方法
}
public class JumppingDemo {
public static void main(String[] args) {
//        Jumpping j = new Jumpping();
        //同抽象类来实现接口
        Jumpping j = new Cat();
        j.jump();
    }
}

```java

			public interface Inter {
			    //变量都是常量默认被public static final 修饰
			    public int num=10;
			    public  final  int num2=20;
			    //相当于int  num=20;
			   // public  static  final  int num3=30;
			    int num3=30;
			    void show();
			    //相当于public void show(){};
			    public  abstract void  method();
				}
				public class InterImpl extends Object implements  Inter{
			   //object是所有类的父类     类实现接口
			    //重写接口中的所有抽象方法
			    @Override
			    public void method() {
			        System.out.println("method");
			    }
			    @Override
			    public void show() {
			    }
			}
			public class InterfaceDemo {
		    public static void main(String[] args) {
		            //向上转型
		            Inter i = new InterImpl();
		//        i.num = 20;
		            System.out.println(i.num);
		//        i.num2 = 40;
		        System.out.println(i.num2);
		        System.out.println(Inter.num);
		    }
		}

public abstract class Animal {
    //成员方法
    private String name;
    private int age;
    //构造方法

    public Animal() {
    }
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
        //set/get方法
    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();
}
		public interface Jumpping {
    //定义接口  并且定义抽象方法
    void jump();
}		
public class Cat extends  Animal implements Jumpping {
    //子类继承父类实现接口
    //构造方法
    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }
    //重写父类抽象方法
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
        //重写接口抽象方法
    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}
public class AnimalDemo {
    public static void main(String[] args) {
        Jumpping j=new Cat();
        j.jump();
        System.out.println("----------------");

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

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

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

//抽象人类
public abstract class Person {
    //成员方法
    private String name;
    private int age;
    // 构造方法
    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
        //get/set方法
    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();
}
//说英语的接口
public interface SpeakEnglish {
    public abstract void speak();
}

public abstract class Player extends Person {
    public Player() {
    }

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

    public abstract void study();
}
public abstract class Coach extends Person {
    public Coach() {
    }

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

    public abstract void teach();
}
public class  PingPangCoach  extends Coach  implements SpeakEnglish{
    public PingPangCoach() {
    }

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

    @Override
    public void teach() {
        System.out.println("乒乓球教练教如何发球和接球");
    }

    @Override
    public void eat() {
        System.out.println("乒乓球教练吃小白菜,喝大米粥");
    }

    @Override
    public void speak() {
        System.out.println("乒乓球教练说英语");
    }
}
ublic class PingPangPlayer extends Player implements SpeakEnglish {
    public PingPangPlayer() {
    }

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

    @Override
    public void study() {
        System.out.println("乒乓球运动员学习如何发球和接球");
    }

    @Override
    public void eat() {
        System.out.println("乒乓球运动员吃大白菜，喝小米粥");
    }

    @Override
    public void speak() {
        System.out.println("乒乓球运动员说英语");
    }
}
public class BasketballCoach extends Coach {
    public BasketballCoach() {
    }

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

    @Override
    public void teach() {
        System.out.println("篮球教练教如何运球喝投篮");
    }

    @Override
    public void eat() {
        System.out.println("篮球教练吃羊肉，喝羊奶");
    }
}
public class BasketballPlayer extends Player {
    public BasketballPlayer() {
    }

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

    @Override
    public void study() {
        System.out.println("篮球运动员学习如何运球和投篮");
    }

    @Override
    public void eat() {
        System.out.println("篮球运动员吃牛肉，和牛奶");
    }
}

	  public class PersonDemo {
	    public static void main(String[] args) {
	        //创建对象
	        PingPangPlayer ppp = new PingPangPlayer();
	        ppp.setName("王浩");
	        ppp.setAge(30);
	        System.out.println(ppp.getName()+","+ppp.getAge());
	        ppp.eat();
	        ppp.study();
	        ppp.speak();
	        System.out.println("--------");
	
	        BasketballPlayer bp = new BasketballPlayer();
	        bp.setName("姚明");
	        bp.setAge(35);
	        System.out.println(bp.getName()+","+bp.getAge());
	        bp.eat();
	        bp.study();
	        System.out.println("------------");
	
	        BasketballCoach bc=new BasketballCoach();
	        bc.setName("杜洋");
	        bc.setAge(25);
	        System.out.println(bc.getName()+","+bc.getAge());
	        bc.eat();
	        bc.teach();
	        System.out.println("---------------");
搬砖的考拉
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多态，抽象类，接口
cl66666666的博客
11-17 136
多态 多态定义 什么是多态： 同一个对象，在不同时刻表现出来的不同形态 多态的前提： 要有继承或实现关系 要有方法的重写 要有父类引用指向子类对象 package com.itxuexi.it11; /* 动物类 */ public class Animal { public int age = 40; public void eat(){ System.out.println("动物吃东西"); } } //----------------------
多态、抽象类和接口
qq_56930747的博客
01-13 2228
目录 一、多态 二、抽象类 三、接口 一、多态 1. 多态的概述 某个事物，在不同的时刻表现出来的不同状态。 eg： Cat c=new Cat(); Animal a=new Cat(); 猫可以是猫类型，即 猫 m=new 猫(); 同时猫也是动物的一种，即 动物 d=new 猫(); 2. 多态的前提 1. 要有继承关系； 2. 要有方法重写，否则就失去了意义。 3. 要有父类对象引用指向子类对象：eg:父 f=new 子()...
java源代码 多态_Java基础知识学习：Java三大特效之多态！
weixin_32483357的博客
02-16 107
1.1 多态的形式多态是继封装、继承之后，面向对象的第三大特性。多态是出现在继承或者实现关系中的。多态体现的格式：父类类型 变量名 = new 子类/实现类构造器;变量名.方法名();多态的前提：有继承关系，子类对象是可以赋值给父类类型的变量。例如Animal是一个动物类型，而Cat是一个猫类型。Cat继承了Animal，Cat对象也是Animal类型，自然可以赋值给父类类型的变量。1.2 多态的...
面向对象编程题汇总
热门推荐
lsqingfeng的博客
06-06 1万+
在授课面向对象这一章节的时候，发现找一些比较贴近的编程题还是比较难的，从网上整理了一下，希望对需要的朋友有帮助。很多是从网上找的，如果侵犯版权请联系我！ 一、类和对象 1.定义一个类Demo,其中定义一个求两个数据和的方法，定义一个测试了Test，进行测试。 2.定义一个长方形类,定义 求周长和面积的方法，然后定义一个测试了Test2，进行测试。 3.定义一个员...
类的多态性：成员变量与成员方法访问特点（C++、Java）
hyl1181的博客
07-31 892
类的多态性：成员变量与成员方法访问特点（C++、Java） 1.C++与Java语言中类的多态格式为： C++：父类名称 &引用对象名 = 子类名称 对象名 Java：父类名称 对象名 = new 子类名称 2.对成员变量与成员方法（函数）访问特点一致，规律如下： 对于成员变量，代码编译和执行时都看父类，以父类为依据（有无及值以父类为标准）； 对于成员方法，编译时以父类为依据（父类无则编译报错），执行时以子类为依据（执行子类方法），但前提是子类必须对方法进行重载，在C++中父类函数还必须为虚函数。
封装、继承和多态以及抽象类和接口
m0_74500911的博客
10-23 503
本文主要说明了Java中类的封装、继承和多态的创建方法及其具体意义。
接口，多态，抽象类，final
08-10
"接口、多态、抽象类、final" 在 Java 编程语言中，接口、多态、抽象类和 final 是四个非常重要的概念，它们在面向对象编程（Object-Oriented Programming，OOP）中扮演着关键角色。 1. 接口 接口是 Java 中的一...
day02-多态&抽象类&接口
06-11
day02-多态&抽象类&接口
Python面向对象之接口、抽象类与多态详解
09-20
在探讨Python面向对象编程的过程中，接口、抽象类和多态是三个核心概念。理解这三个概念能够帮助我们在设计和实现软件时保持良好的可扩展性和复用性。 首先，接口在某些编程语言（比如Java）中是定义一个类必须实现...
Java异常处理的五个关键字：try、catch、finally、throw、throws
weixin_44313232的博客
02-20 3979
java.lang.Throwable: 类是java语言中所有错误或异常的超类： Exceptio:编译期异常，进行编译（写代码）java程序出现异常。 RuntimeException:运行异常，java程序运行过程出现问题。 相当于程序得了一个小毛病，把异常处理掉，程序可以执行。 Error:错误 错误就相当于程序得了一个无法治愈的毛病，必须修改源代码，程序才能执行。 异常产生的过程： 如果...
java8 分组排序数据丢失
weixin_44313232的博客
07-22 551
java8分组排序
继承 修饰符
weixin_44313232的博客
01-27 351
1.继承 继承是面向对象的三大特征之一，可以使子类具有父类的属性和方法， 还可以在子类中重新定义。 继承：是通过extends实现的。 格式：class 子类extends 父类（）{} public class fu { public void show(){ System.out.println("父类方法show被调用"); } } //子类集成父类的格式 p...
时间格式YYYY-MM-DD‘T‘hh:mm:ssZ
最新发布
weixin_44313232的博客
04-27 337
为什么同样的时间格式生成就是2024-04-118T05:45:15+0800，而校验理想的是：2024-04-18T05:45:15+0800？
JDBC Template&&连接池
weixin_44313232的博客
03-17 307
连接池 连接池其实就是一个容器(集合)，存放数据库连接的容器。 优点 **节约资源，减轻服务器压力 提高连接复用性，用户访问高效** 1**. DataSource** 功能 * 获取连接：Connection getConnection(); * 归还连接：connection.close(); 我们大家已经养成了习惯 今天使用连接池技术后，此方法的调用不再是关闭连接，而是归还连接到容器（连...
JavaScript&&CSS
weixin_44313232的博客
03-17 215
CSS常用属性 1）字体和文本 font-size:字体大小 font-weight:字体粗细 " bold"粗体 font-style：样式 "italic"斜体 font-family：类型 2.文本 color:颜色 line-height:行高 text-align:内容对齐方式 text-decoration:装饰 取值：no...
io流
weixin_44313232的博客
03-03 181
IO流分类： 根据流向分为：输入流****和输出流。 根据格局数据类型分为：字节流和字符流。 字节流 字节流的输出流： public FileOutputStream(File file) ：创建文件输出流以写入由指定的 File对象表示的文件。 目的地是一个文件夹的路径 FileOutputStream fos1 =new FileOutputStream(new File("09_IOAn...
HTML
weixin_44313232的博客
03-17 176
web JavaWeb： 使用Java语言开发基于互联网的项目 软件架构： 1.C/S: Client/Server 客户端/服务器端 * 在用户本地有一个客户端程序，在远程有一个服务器端程序 * 如：QQ，迅雷… * 优点： 1. 用户体验好 缺点： 1. 开发、安装，部署，维护 麻烦 2.B/S: Browser/Server 浏览器/服务器端 只需要一个浏览器，用户通过不同的网址(U...
Collectios list set
weixin_44313232的博客
02-20 172
java.util.Collection接口 所有单列集合的最顶层的接口,里边定义了所有单列集合共性的方法 任意的单列集合都可以使用Collection接口中的方法 共性的方法: public boolean add(E e)： 把给定的对象添加到当前集合中 public void clear() :清空集合中所有的元素。 public boolean remove(E e): 把给定的对象在...
HTML&&CSS
weixin_44313232的博客
03-17 165
1.1 表格标签 table – 一个表格 caption – 表格标题 tr – 一行 td – 普通单元格 th – 标题单元格 特点：居中且加粗 table常用属性 border:边框 width:宽度 align：表格对齐方式 cellspacing：单元格的间距，一般设置为0 cellpadding：单元格的内边距，一般设置为0 tr常用属性 align：内容的对齐方式 height:行...
Java OOP：接口、多态、抽象类与final关键字解析
"接口，多态，抽象类和final关键字是Java编程中面向对象特性的重要组成部分。理解并熟练掌握这些概念对于编写高质量的Java代码至关重要。本文将详细阐述这些概念及其应用。 首先，我们来看一下接口（Interface）。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值