精华内容
下载资源
问答
  • 创建一个类继承抽象类
    千次阅读
    2020-12-31 11:28:47

    抽象类

    1.抽象类的定义

    抽象类是为子类提供一个规范,这就必须联系到继承;

    抽象类的制定就是让子类继承的;

    public abstract 类名{

    //类体

    //抽象方法

    修饰符 abstract 返回值类型 方法名(参数列表);

    }

    *抽象方法没有方法体:public abstract void test();

    **普通方法有方法体:public  void test(){//方法体};

    (1)定义一个类,如果这个类是抽象类,那么这个类中至少含有一个抽象方法;

    (2)再抽此昂类中的方法不一定是抽象方法,但含有抽象类的方法一定是抽象类

    2.抽象类的使用

    @Override用来检测是否重写成功

    我们可以在抽象类中添加未实现的方法(抽象方法)

    (1)一个类继承了抽象类,就必须重写该抽象类的所有抽象方法

    (2)如果有一个类没有重写抽象类的抽象方法,那么这个类也要重新定义为抽象类

    示例代码:

    package com.java1995;

    /**

    * 猫科动物类

    * @author ideaor

    *

    */

    public abstract class Feline {

    private int legCount=4;

    private String headShape="round";

    private boolean meatEater=true;

    /**

    * 普通方法࿰

    更多相关内容
  • java基础之继承抽象类

    千次阅读 2021-03-05 15:25:16
    继承 :就是子类继承父类的非私有属性和行为二、特点1、子类和父类中出现了同名的成员变量时,在子类中需要访问父类中非私有成员变量时,需要使用 super 关键字格式:super.父类成员变量名2、如果子类父类中出现...

    一、继承 :就是子类继承父类的非私有属性和行为

    二、特点

    1、子类和父类中出现了同名的成员变量时,在子类中需要访问父类中非私有成员变量时,需要使用 super 关键字

    格式:super.父类成员变量名

    2、如果子类父类中出现重名的成员方法,这时的访问是一种特殊情况,叫做方法重写

    重写【覆盖】:子类中出现与父类一模一样的方法时(返回值、方法名、参数列表等都相同),子类的方法会覆盖父类的方法

    注意事项

    a. 子类方法覆盖父类方法,必须要保证权限大于等于父类权限。

    b. 子类方法覆盖父类方法,返回值类型、函数名和参数列表都要一模一样。

    3、继承关系中:字父类的构造方法特点

    a.子类构造方法中不写父类构造方法,会默认隐含super()调用,所以一定是先调用父类构造,然后调用子类构造

    b.子类构造可以通过super关键字来调用父类构造,从而初始化父类成员变量

    c.super的父类构造调用,必须放在子类构造方法的第一个语句,而且仅能出现一次

    三、 抽象类

    1、定义

    抽象方法 : 没有方法体的方法。

    格式:

    修饰符 abstract 返回值类型 方法名 (参数列表);

    抽象类 :包含抽象方法的类

    格式:

    abstract class 类名字 { }

    2、抽象的使用:继承抽象类的子类必须重写父类所有的抽象方法

    3、抽象类的使用注意事项

    a、抽象类不能创建对象,如果创建,编译无法通过而报错。只能创建其非抽象子类的对象。

    理解:假设创建了抽象类的对象,调用抽象的方法,而抽象方法没有具体的方法体,没有意义。

    b、可以有构造方法,是供子类创建对象时,初始化父类成员使用的。

    理解:子类的构造方法中,有默认的super(),需要访问父类构造方法。

    c、 抽象类中,可以包含非抽象方法,但是有抽象方法的类必定是抽象类。

    理解:未包含抽象方法的抽象类,目的就是不想让调用者创建该类对象,通常用于某些特殊的类结构设计。

    d、抽象类的子类,必须重写抽象父类中所有的抽象方法,否则,编译无法通过而报错。除非该子类也是抽象类。

    理解:假设不重写所有抽象方法,则类中可能包含抽象方法。那么创建对象后,调用抽象的方法,没有意义

    展开全文
  • java学习笔记(12-继承抽象类

    千次阅读 2021-03-15 17:45:41
    1.继承关键字extendsjava中继承特点:在Java中,类只支持单继承,不允许多继承,也就是说一个类只能有一个直接父类多个类可以继承一个父类在Java中,多层继承是可以的,即一个类的父类可以再去继承另外的父类,例如C...

    1.继承关键字extends

    java中继承特点:

    在Java中,类只支持单继承,不允许多继承,也就是说一个类只能有一个直接父类

    多个类可以继承一个父类

    在Java中,多层继承是可以的,即一个类的父类可以再去继承另外的父类,例如C类继承自B类,而B类又可以去继承A类,这时,C类也可称作A类的子类

    子类只能获取父类非私有成员

    super:可以获取父类的成员变量和成员方法,用法和this是相似的

    package com.daigua12;

    public class ExtendsDemo {

    public static void main(String[] args) {

    Dota1 d = new Dota1();

    d.start();

    d.stop();

    Lol1 l = new Lol1();

    l.start();

    l.stop();

    }

    }

    class Game {

    String name;

    double version;

    String agent;

    public static void start() {

    System.out.println("游戏启动了!");

    }

    public static void stop() {

    System.out.println("游戏停止了!");

    }

    }

    class Dota1 extends Game{

    }

    class Lol1 extends Game{

    }

    2.访问变量的顺序

    package com.daigua12;

    /*

    * 继承中成员变量的特点

    * 子类只能获取父类非私有成员

    * 子父类中成员变量的名字不一样直接获取父类的成员变量

    * 子父类中成员变量名字是一样的获取的是子类的成员变量

    *

    * 就近原则:谁离我近我就用谁

    * 如果有局部变量就使用局部变量

    * 如果没有局部变量,有子类的成员变量就使用子类的成员变量

    * 如果没有局部变量和子类的成员变量,有父类的成员变量就使用父类的成员变量

    * 啥都没有,出错了!!!

    *

    * super:可以获取父类的成员变量和成员方法,用法和this是相似的

    */

    public class ExtendsDemo3 {

    public static void main(String[] args) {

    Kid3 k = new Kid3();

    k.show();

    }

    }

    class Dad3 {

    String name = "建霖";

    }

    class Kid3 extends Dad3 {

    String name = "四葱";

    public void show() {

    String name = "五葱";

    System.out.println(super.name);

    System.out.println(this.name);

    System.out.println(name);

    }

    }

    3.方法重写

    package com.daigua12;

    /*

    * 方法重写的应用场景:当父类的方法不能完全满足子类使用,这个时候子类重写父类的方法,

    * 并可以在方法中使用关键字super调用父类的方法,这样做即可以保有父类的功能,也可以拥有子类特有的功能

    * 方法重写的注意事项:

    * 不能重写父类私有的方法

    * 权限必须大于等于父类方法的权限

    *

    * 注解:@

    *

    */

    public class ExtendsDemo5 {

    public static void main(String[] args) {

    NewPhone np = new NewPhone();

    np.call();

    }

    }

    class Phone {

    void call() {

    System.out.println("打电话");

    }

    }

    class NewPhone extends Phone {

    @Override

    public void call() {

    super.call();

    System.out.println("录音");

    // System.out.println("打电话");

    // super.call();

    }

    }

    4.构造方法调用顺序

    package com.daigua12;

    /*

    * 继承中构造方法的执行顺序

    * 在子父类中,创建子类对象,调用子类的构造方法,

    * 在子类的构造方法的第一行代码如果没有调用父类的构造或者没有调用子类的其他构造,则默认调用父类无参构造

    * 为什么要调用父类构造?

    * 因为需要给父类的成员变量初始化

    * 肯定会先把父类的构造执行完毕,在去执行子类构造中的其他代码

    *

    * 我是父类无参构造 --- 我是子类有参构造 --- 我是子类无参构造

    */

    public class ExtendsDemo6 {

    public static void main(String[] args) {

    // Die d = new Die();

    Zi6 z = new Zi6();

    }

    }

    class Die6 {

    public Die6() {

    System.out.println("我是父类无参构造");

    }

    public Die6(int num) {

    System.out.println("我是父类有参构造");

    }

    }

    class Zi6 extends Die6 {

    public Zi6() {

    // super(1);

    // super();

    this(1);// 不会再调用父类的无参构造了

    System.out.println("我是子类无参构造");

    }

    public Zi6(int num) {

    // 会默认调用父类无参构造

    System.out.println("我是子类有参构造");

    }

    }

    5.抽象类

    a5329b28adf6c147ef21ef4ec6b5484e.png

    package com.daigua12;

    public class AbstractDemo {

    public static void main(String[] args) {

    Cat c = new Cat();

    c.eat();

    }

    }

    // 抽象类,一般作为基类

    abstract class Animal {

    public abstract void eat();

    // 非抽象方法,子类可以不用重写

    public void run() {

    System.out.println("running");

    }

    }

    class Cat extends Animal {

    @Override

    public void eat() {

    System.out.println("小猫吃鱼!");

    }

    }

    6.抽象类成员特点

    package com.daigua12;

    /*

    * 抽象类的成员特点:

    * 成员变量

    * 可以有成员变量

    * 可以有常量

    * 成员方法

    * 可以有抽象方法

    * 可以有非抽象方法

    * 构造方法

    * 可以有构造方法的,需要对抽象类的成员变量进行初始化

    *

    * final:修饰类、成员变量、成员方法

    */

    public class AbstractDemo3 {

    public static void main(String[] args) {

    Dog d = new Dog();

    d.barking();

    }

    }

    abstract class Animal2 {

    String name = "哮天犬";

    // final变量只能初始化一次

    final int num = 10;

    public Animal2() {

    System.out.println("我是抽象类的构造方法");

    }

    public abstract void eat();

    public void run() {

    }

    }

    class Dog extends Animal2 {

    public void barking() {

    System.out.println(name);

    System.out.println(num);

    }

    @Override

    public void eat() {

    // TODO Auto-generated method stub

    }

    }

    7.抽象类案例1-老师

    要求:

    老师类:

    属性:姓名,年龄,性别

    行为:讲课

    基础班老师:

    属性:姓名,年龄,性别

    行为:讲基础班课程

    就业班老师:

    属性:姓名,年龄,性别

    行为:讲就业班课程

    package com.daigua12;

    /*

    * 老师类:

    属性:姓名,年龄,性别

    行为:讲课

    基础班老师:

    属性:姓名,年龄,性别

    行为:讲基础班课程

    就业班老师:

    属性:姓名,年龄,性别

    行为:讲就业班课程

    * */

    public class AbstractTeacher {

    public static void main(String[] args) {

    BasicTeacher b1 = new BasicTeacher("鲁迅", 18, "男");

    b1.action();

    WorkTeacher w1 = new WorkTeacher("菩提老祖", 1008, "未知");

    w1.action();

    }

    }

    abstract class Teacher {

    String name;

    int age;

    String gender;

    public Teacher(String name, int age, String gender) {

    this.age = age;

    this.gender = gender;

    this.name = name;

    }

    public abstract void action();

    }

    class BasicTeacher extends Teacher {

    public BasicTeacher(String name, int age, String gender) {

    // TODO Auto-generated constructor stub

    super(name, age, gender);

    }

    @Override

    public void action() {

    // TODO Auto-generated method stub

    System.out.println("讲基础班课程");

    }

    }

    class WorkTeacher extends Teacher {

    public WorkTeacher(String name, int age, String gender) {

    // TODO Auto-generated constructor stub

    super(name, age, gender);

    }

    @Override

    public void action() {

    // TODO Auto-generated method stub

    System.out.println("讲就业班课程");

    }

    }

    8.抽象类的细节问题

    A:抽象类关键字abstract可以和哪些关键字共存?

    1.private:

    私有的方法子类是无法继承到的,也不存在覆盖,而abstract和private一起使用修饰方法,abstract既要子类去实现这个方法,而private修饰子类根本无法得到父类这个方法。互相矛盾。

    2.final:

    抽象类不能和final共存,因为抽象类自身无法创建对象,我们需要通过子类创建对象,一旦抽象类使用final关键字,那么抽象类就没有子类

    抽象方法不能和final共存,因为抽象方法后期需要被子类重写,一旦加final无法重写

    3.static:

    抽象方法不能和static关键字共存,因为一旦加static我们就可以通过类名直接访问抽象方法,由于抽象方法没有方法体,没有任何意义,也不允许这样做

    B:抽象类中是否可以不定义抽象方法?

    是可以的,那这个抽象类的存在到底有什么意义呢?不让该类创建对象,方法可以直接让子类去使用

    C:抽象类是否有构造函数?

    有,抽象类的构造函数,是由子类的super语句来调用,用于给抽象类中的成员初始化

    展开全文
  • 设计一个抽象类图形类,在该类中包含有至少两个抽象方法求周长和求面积,分别定义圆形类、长方形类、正方形类来继承图形类,并实现上述两个方法。并创建实例验证。 直接上代码了 package ThirdDay; abstract class...

    设计一个抽象类图形类,在该类中包含有至少两个抽象方法求周长和求面积,分别定义圆形类、长方形类、正方形类来继承图形类,并实现上述两个方法。并创建实例验证。

    直接上代码了

    package ThirdDay;
    
     abstract class Shape {
        //计算面积
        public abstract Double calculateS();
    
        //计算周长
        public  abstract Double calculateC();
    }
    
    //长方形类
      class Rectangle extends  Shape{
         private double l;
         private double s;
    
        public Rectangle(double l, double s) {
            this.l = l;
            this.s = s;
        }
    
        public double getL() {
            return l;
        }
    
        public void setL(double l) {
            this.l = l;
        }
    
        public double getS() {
            return s;
        }
    
        public void setS(double s) {
            this.s = s;
        }
    
        @Override
        public Double calculateS() {
            return s*l;
        }
    
        @Override
        public Double calculateC() {
            return 2*(s+l);
        }
    
    }
    
      class Square extends Shape{
    
         private double sideLength;
    
          public Square(double sideLength) {
              this.sideLength = sideLength;
          }
    
          public double getSideLength() {
              return sideLength;
          }
    
          public void setSideLength(double sideLength) {
              this.sideLength = sideLength;
          }
    
          @Override
          public Double calculateS() {
              return Math.pow(sideLength,2);
          }
    
          @Override
          public Double calculateC() {
              return 4*sideLength;
          }
      }
    
      class Triangle extends Shape{
    
         private double a;
         private double b;
         private double c;
    
          public Triangle(double a, double b, double c) {
              this.a = a;
              this.b = b;
              this.c = c;
          }
    
          public double getA() {
              return a;
          }
    
          public void setA(double a) {
              this.a = a;
          }
    
          public double getB() {
              return b;
          }
    
          public void setB(double b) {
              this.b = b;
          }
    
          public double getC() {
              return c;
          }
    
          public void setC(double c) {
              this.c = c;
          }
    
          @Override
          public Double calculateS() {
              double s = (a + b + c) / 2;
              double area = Math.pow(s*((s - a)*(s - b)*(s - c)), 0.5);
              return area;
          }
    
          @Override
          public Double calculateC() {
              return a+b+c;
          }
      }
    
    
    class Circle extends Shape{
    
        private double r;
    
          public Circle(double r) {
              this.r = r;
          }
    
          public double getR() {
              return r;
          }
    
          public void setR(double r) {
              this.r = r;
          }
    
          @Override
          public Double calculateS() {
              return Math.PI*r*r;
          }
    
          @Override
          public Double calculateC() {
              return 2*Math.PI*r;
          }
      }
    
    
      class Graphice {
          public static void main(String[] args) {
              Circle circle=new Circle(2.5);
              System.out.println("半径为:"+circle.getR()+"的圆面积为:"+circle.calculateC());
              System.out.println("半径为:"+circle.getR()+"的圆周长为:"+circle.calculateS());
              Triangle triangle=new Triangle(3,4,5);
              if (triangle.getA() > 0 && triangle.getB()> 0 && triangle.getC() > 0 &&
                      (triangle.getA()+ triangle.getB()) > triangle.getC() && (triangle.getA() + triangle.getC()) > triangle.getB() && (triangle.getB() + triangle.getC()) > triangle.getA()) {
                  System.out.println("三角形的a,b,c三边长为:"+triangle.getA()+","+triangle.getB()+","+triangle.getC());
                  System.out.println("三角形的周长为 = " + triangle.calculateC());
                  System.out.println("三角形的面积 = " + triangle.calculateS());
              }else {
                  System.out.println("\n三角形三边不合法! 三角形创建失败! "
                          + "\n请重新输入三边\n");
              }
              Rectangle rectangle=new Rectangle(5,2);
              System.out.println("长为:"+rectangle.getL()+"宽为:"+rectangle.getS()+"的长方形面积为:"+rectangle.calculateS());
              System.out.println("长为:"+rectangle.getL()+"宽为:"+rectangle.getS()+"的长方形周长为:"+rectangle.calculateC());
              Square square=new Square(2);
              System.out.println("边长为:"+square.getSideLength()+"的正方形面积为:"+square.calculateS());
              System.out.println("边长为:"+square.getSideLength()+"的正方形周长为:"+square.calculateC());
          }
      }
    

    运行结果如下

    半径为:2.5的圆面积为:15.707963267948966
    半径为:2.5的圆周长为:19.634954084936208
    三角形的a,b,c三边长为:3.0,4.0,5.0
    三角形的周长为 = 12.0
    三角形的面积 = 6.0
    长为:5.0宽为:2.0的长方形面积为:10.0
    长为:5.0宽为:2.0的长方形周长为:14.0
    边长为:2.0的正方形面积为:4.0
    边长为:2.0的正方形周长为:8.0
    
    
    展开全文
  • 在java中,当创建一个子类...提个问题:如果当创建一个子类对象会先创建父类对象的话,那么如果父类是抽象类的话,那该抽象父类也会被实例化喽,这与抽象类不能实例化相互矛盾啊! package javase5; pub...
  • 如果抽象类没有实现接口中的所有有方法(不用写方法体),那么A类继承抽象类后就必须重写抽象类没有实现的方法。所以为了方便的去使用个别方法,可以让抽象类去实现接口的所用方法(不用写方法体),这样A类就可以...
  • java-抽象类和继承抽象类

    万次阅读 2018-02-09 16:17:15
    抽象类和继承抽象类 抽象类不能直接实例化,需要创建一个指向自己的对象引用(其子类)来实例化 代码: public class Main { public static void main(String[] args) { /* People people = new People(); *...
  • 定义一个抽象类shape,它包含一个抽象方法getArea() 定义一个抽象类Shape,它包含一个抽象方法getArea(),从Shape类派生出Rectangle和Circle类,这两个类都用getArea()方法计算对象面积,编写应用程序使用Rectangle...
  • 抽象方法:就是加上abstract关键字,然后去掉大括号,...2. 必须使用一个子类来继承抽象父类 3. 子类必须覆盖重写抽象父类当中所有的抽象方法(注: 覆盖重写(实现):去掉抽象方法的abstract关键字,然后补上方法体...
  • 抽象类为什么不能创建对象?

    千次阅读 2020-07-18 21:37:02
    在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类抽象类往往用来表征对问题领域...
  • 创建一个抽象类动物类以及以下几个接口:进食的接口、睡觉的接口、思考的接口、说话的接口。分别定义猫类、人类、鸟类继承动物类并选择实现上述的接口,并创建实例验证。 上代码 package ThirdDay; public abstract...
  • JAVA 抽象类,抽象方法

    千次阅读 2021-04-22 21:18:22
    一个抽象类Animal中有一个抽象方法run.public class Animal{public abstract void run();}那么他的子类必须要实现run这个方法。不是实现的话编译就会报错。public class Dog{@Overridepublic void r...
  • 1、继承抽象类,必须重写抽象类中所有抽象方法。 2、继承普通类,可以重写也可以不重写父类的方法。 3、实现接口则必须实现接口中的所有方法。(接口中的方法均为抽象方法)。 二、抽象类、接口的区别 1、类要被子类...
  • 抽象类继承总结

    千次阅读 2018-08-04 14:31:37
    继承:是指在一个现有的基础上去构建一个新的,构建出来的新被称作子类,现有被称作父类,子类会自动拥有父类所有 继承的好处:可继承的属性和方法。    提高了代表的可维护性  提高了代码的...
  • 纯虚函数 、抽象类 、多重继承 、二义性问题 、菱形继承 、虚基类 、从内存布局看虚继承的底层实现原理
  • class Shape: def __init__(self,areas=0,primeters=0): self.areas=areas self.Primeters=primeters def GetPrimeter(self): pass def GetArea(self): pass class Triangle(Shape): def __init__(self,said...
  • 面向对象编程之继承、多态、封装、抽象类、接口、包继承类的继承格式为什么要继承继承的特点继承的种类及关键字访问权限多态向上转型动态绑定方法重写重写和重载的区别比较多态的优点封装实现Java的封装封装的优点...
  • 继承extends与 抽象类 abstract

    千次阅读 2018-05-01 11:51:29
    继承的父子成员特点子类继承父类: 1:子类可以访问父类...a:一个子类只能有一个父类(一个儿子只能有一个爹) b:一个父类可以有多个子类(一个爹可以有多个儿子) c:任何一个类如果没有指定父类,则他的父类默认就是Obj...
  • 创建抽象类

    千次阅读 2017-11-08 21:37:00
    创建抽象类package omd;public abstract class cc {//创建抽象类cc abstract void distance();//创建抽象类方法 public static void main(String[] args) { // TODO 自动生成的方法存根 Car QQ=new Car();//定义...
  • C#中的抽象类、抽象属性、抽象方法

    千次阅读 多人点赞 2020-06-10 00:51:31
    前言:本博文讲述了C#面向对象中的抽象类,通过本博文的阅读,读者可以掌握C#抽象类的概念、应用、好处以及一些特性。...注意:类是一个模板,那么抽象类就是一个不完整的模板。我们自然不可以使用不完
  • C#OOP之八 继承 接口和抽象类

    千次阅读 2016-04-28 18:24:53
    继承 在现实生活中有所谓的“种瓜得瓜、种豆得豆”的说法,在生物学概念上就是“遗传”的概念,在面向对象中...继承一次最常用的就是通过合法程序(比如遗嘱)从别人那里接受财产或爵位等,有点类似于世袭制。 另外
  • 抽象类和接口

    千次阅读 2020-11-24 19:38:35
    Java语言规定,如果一个类包含了抽象的方法。那么该类就是一个抽象类 定义: ​ 抽象方法:没有方法体的方法 ​ 抽象类:包含抽象方法的类 abstract关键字的使用格式 ​ 抽象方法 ​ 使用abstract关键字修饰...
  • C#中抽象类与抽象方法的详解

    万次阅读 2020-06-17 17:41:11
    抽象类的含义是什么? 抽象类怎么创建? 抽象类的规则有哪些? 抽象方法? 抽象类被运用的意义是什么?
  • 抽象类不能创建对象,其创建对象没有意义,但是抽象类可以保存类事物具备的共同属性和行为,让子类进行继承抽象类的构造方法不是给自己用的,而是为了让子类调用构造方法创建对象时初始化用的 ...
  • 我之前做了简易计算器的简单工厂模式,效果与你这是一样的~~~~你的抽象类Shape里面的方法area()和perimeter(),可以参考的计算器的GetResult()都是虚方法(使用virtual 关键字),然后在计算面积、周长的子类中分别...
  • Java中定义抽象类Shape,其中包含抽象方法double getPeremeter( )求周长和double getArea( )求面积。 定义一个矩形类,继承抽象类,并自行扩充成员变量和方法,定义一个方法一次显示长和宽、周长和面积。
  • 创建型模式之简单工厂模式——接口和抽象类

    万次阅读 多人点赞 2021-10-05 09:58:45
    输出结果 接口和抽象类 补充一个知识: 接口和抽象类有什么区别? 什么时候用接口,什么时候用抽象类? 接口和抽象类有什么区别? 接口是针对方法的整合,抽象类是针对子类的整合。 人有男人,女人,人是抽象类。人...
  • [Java] 继承抽象类相关题目

    千次阅读 2020-04-06 05:13:44
    本文介绍了 Java 中继承抽象类的相关题目。。。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 462,102
精华内容 184,840
关键字:

创建一个类继承抽象类