精华内容
下载资源
问答
  • 抽象方法不能有具体的实现
    万次阅读
    2020-12-02 13:38:45

    接口可以继承接口。

    抽象类并不能继承接口,但可以实现接口。

    抽象类可以继承具体类,前提是具体类必须具有构造函数且具有访问权限。这里需要说明,当一个具体类没有写构造函数时,系统会自动生成默认的无参构造器,意味着没有写构造函数的具体类也可以被抽象类继承。但是,一旦将具体类的无参构造器设置访问修饰符为 private 时,抽象类则不可以继承。

    抽象类可以有静态的 main 方法。抽象类在面向对象中是被用来描述现实中的抽象事物, 抽象类没有对象概念所以不能被实例化. 但可以定义属性和方法, 其中属性方法都可以是静态的. 静态的意义其实就是在栈内存中只有一个, 所以该成员也会先于对象出现在内存中, 所以静态并没有违反抽象的原则. 抽象类中可以定义静态成员.

    interface IA{}
    interface IB{}
    interface I extends IA,IB{}//接口可以继承多个接口
    abstract class E implements IA{} //抽象类可以实现接口,但不可以继承接口
    abstract class F extends C{}//抽象类可以继承具体类
    class D{private D(){}}
    //abstract class G extends D{}//Implicit super constructor D() is not visible for default constructor. Must define an explicit constructor抽象类不可以继承无权限构造器的具体类
    abstract class H{public static void main() {}}//抽象类可以有静态的main方法
    
    更多相关内容
  • 抽象类中是否可以静态的main方法? 上面这个题目我们来慢慢的剖析一下。先从基本的概念说起。 一、接口 官方解释:Java接口是一系列方法的声明,是一些方法特征的集合,一个接口只有方法的特征没有方法实现,...

    有一个面试四连击的题目:接口是否可继承接口?抽象类是否可实现(implements)接口?抽象类是否可继承具体类?抽象类中是否可以有静态的main方法?
    上面这个题目我们来慢慢的剖析一下。先从基本的概念说起。

    一、接口

    官方解释:Java接口是一系列方法的声明,是一些方法特征的集合,一个接口只有方法的特征没有方法的实现,因此这些方法可以在不同的地方被不同的类实现,而这些实现可以具有不同的行为(功能)。
    又到了我最喜欢打比方的环节了:我们身边最常见的接口就是电脑的usb接口了。我们可以想想,我们电脑的usb接口是不是就那么几个但是没有任何的具体的功能?但是当我们把u盘插到usb接口的时候,我们可以进行数据的传输;
    当我们把鼠标插入usb接口的时候,我们可以左键打开网页、文件夹等更多的功能;当我们把键盘插入到usb接口的时候我们可以打字,等等。虽然接入不同的设备可以进行不同的操作,但是上述的设备操作都是和电脑的数据交互。
    所以电脑在设置usb接口的时候,并没有实现具体的读写数据的功能,而是但不同的设备接入usb接口就可以实现不同的数据读写功能。这就是接口的好处,试想:如果每个接口都有特定的功能,鼠标要插这个接口,键盘插那个接
    口。那电脑就全是接口了,大大的浪费了资源,而且还不好看。

    接口的特点以及重点:
    1、并不能直接去实例化一个接口,因为接口中的方法都是抽象的,是没有方法体的。但是,我们可以使用接口类型的引用指向一个实现了该接口的对象(键盘、鼠标,…),并且可以调用这个接口中的方法。
    2、一个类可以实现不止一个接口。键盘可以连接戴尔的接口、华硕的接口、联想的接口。
    3、接口也可以继承,并且可以多继承。一个接口可以继承于另一个接口,或者另一些接口。比如现在的很多人电脑的usb接口不够用,所以有了usb接口拓展。
    4、接口中所有的方法都是抽象的和public的,所有的属性都是public,static,final的。
    5、一个类如果要实现某个接口的话,那么它必须要实现这个接口中的所有方法。我们在使用编辑器编写的时候就会自动提示:
    在这里插入图片描述
    否则的话会报错:
    在这里插入图片描述
    接口的实例:

    public interface Demo8 {
    	void say();
    	int add();
    }
    
    public class Demo7 implements Demo8 {
    	public static void main(String[] args) {
    		Demo7 demo7 = new Demo7();
    		demo7.say();
    		System.out.println(demo7.add());
    	}
    	public void say() {
    		System.out.println("你好啊");
    	}
    	public int add() {
    	    int i=1;
    	    int j=2;
    		return i+j;
    	}
    }
    
    public interface Demo9 extends Demo8{
    	void print(String name);
    }
    

    一个类实现 一个接口,如果这个接口继承了另一个接口,那么这个类除了实现这个接口的所有方法以外,还要实现被继承的那个接口的所有方法:

    
    public class Demo10 implements Demo9 {
    
    	public static void main(String[] args) {
    		
    
    	}
    
    	@Override
    	public void say() {
    		// TODO Auto-generated method stub
    		
    	}
    
    	@Override
    	public int add() {
    		// TODO Auto-generated method stub
    		return 0;
    	}
    
    	@Override
    	public void print(String name) {
    		// TODO Auto-generated method stub
    		
    	}
    
    }
    

    二、抽象类

    在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。

    抽象类除了不能实例化对象之外,类的其它功能依然存在,成员变量、成员方法和构造方法的访问方式和普通类一样。具有抽象方法的类一定为抽象类。

    由于抽象类不能实例化对象,所以抽象类必须被继承,才能被使用。也是因为这个原因,通常在设计阶段决定要不要设计抽象类。

    父类包含了子类集合的常见的方法,但是由于父类本身是抽象的,所以不能使用这些方法。

    在Java中抽象类表示的是一种继承关系,一个类只能继承一个抽象类,而一个类却可以实现多个接口。

    抽象类用来描述一种类型应该具备的基本特征与功能, 具体如何去完成这些行为由子类通过方法重写来完成,这点与接口很像,所以它们会被作为一类的面试题进行考察如:
    猫科均会吼叫,但属于猫科的猫与老虎、豹子等它们吼叫的声音确实不同。所以猫科这就是一个类,它只规定了猫科这类的动物有吼叫功能,但并不明确吼叫的细节,吼叫的细节的内容应该由猫与老虎这样的猫科子类重写吼叫的方法具体实现。
    即抽象方法指只有功能声明,没有功能主体实现的方法,与接口中的方法类似,但是抽象方法中除了可以有抽象方法还可以有具体的方法。

    抽象类的实例:

    public abstract class Demo11 {
    
    	   private String name;
    	   private String address;
    	   private int number;
    	   public Demo11(String name, String address, int number)
    	   {
    	      System.out.println("Constructing an Employee");
    	      this.name = name;
    	      this.address = address;
    	      this.number = number;
    	   }
    	   public double computePay()
    	   {
    	     System.out.println("Inside Employee computePay");
    	     return 0.0;
    	   }
    	   public void mailCheck()
    	   {
    	      System.out.println("Mailing a check to " + this.name
    	       + " " + this.address);
    	   }
    	   public String toString()
    	   {
    	      return name + " " + address + " " + number;
    	   }
    	   public String getName()
    	   {
    	      return name;
    	   }
    	   public String getAddress()
    	   {
    	      return address;
    	   }
    	   public void setAddress(String newAddress)
    	   {
    	      address = newAddress;
    	   }
    	   public int getNumber()
    	   {
    	     return number;
    	   }
    }
    

    可以看到尽管该类是抽象类,但是它仍然有 3 个成员变量,7 个成员方法和 1 个构造方法。但是如果想实例化该类,则会报错:提示不能实例化Demo11
    在这里插入图片描述
    在这里插入图片描述
    所以抽象类只能通过被继承:

    public class Demo12 extends Demo11
    {
    	   private double salary; //Annual salary
    	   public Demo12(String name, String address, int number, double
    	      salary)
    	   {
    	       super(name, address, number);
    	       setSalary(salary);
    	   }
    	   public void mailCheck()
    	   {
    	       System.out.println("Within mailCheck of Salary class ");
    	       System.out.println("Mailing check to " + getName()
    	       + " with salary " + salary);
    	   }
    	   public double getSalary()
    	   {
    	       return salary;
    	   }
    	   public void setSalary(double newSalary)
    	   {
    	       if(newSalary >= 0.0)
    	       {
    	          salary = newSalary;
    	       }
    	   }
    	   public double computePay()
    	   {
    	      System.out.println("Computing salary pay for " + getName());
    	      return salary/52;
    	   }
    	}
    
    package Demo1;
    
    public class Demo10 {
    
    	public static void main(String[] args) {
    		
    		  Demo12 demo12 = new Demo12("张三", "北京", 3, 3600.00);
    	      Demo11 demo11 = new Demo12("李四", "上海", 2, 2400.00);
    	 
    	      System.out.println("Call mailCheck using Salary reference --");
    	      demo12.mailCheck();
    	 
    	      System.out.println("\n Call mailCheck using Employee reference--");
    	      demo12.mailCheck();
    	}
    
    }
    
    

    在这里插入图片描述
    所以尽管不能实例化一个抽象类,但是可以实例化一个继承了抽象类的子类,然后将抽象类的引用指向子类的对象。

    如果一个类中它拥有抽象方法,那么这个类就必须是抽象类,抽象类可以没有抽象方法,但是如果有抽象方法的类,必须被申明为抽象类。

    public abstract class Demo11
    {
       private String name;
       private String address;
       private int number;
       //抽象方法
       public abstract double computePay();
    }
    

    如果一个抽象类中有抽象方法,那么任何继承它的子类都必须重写父类的抽象方法,或者子类也可以声明自身为抽象类。但是最终,必须有子类实现该抽象方法,否则,从最初的父类到最终的子类都不能用来实例化对象,那么就没有任何的意义了。
    另外构造方法,类方法(用 static 修饰的方法)不能声明为抽象方法。

    抽象类可实现接口,并且可以不实现接口中的方法,但是继承抽象类的实体类必须实现接口中的方法。

    public abstract class Demo11 implements Demo9{
    
    	   private String name;
    	   private String address;
    	   private int number;
    	   public Demo11(String name, String address, int number)
    	   {
    	      System.out.println("Constructing an Employee");
    	      this.name = name;
    	      this.address = address;
    	      this.number = number;
    	   }
    	   public double computePay()
    	   {
    	     System.out.println("Inside Employee computePay");
    	     return 0.0;
    	   }
    	   public void mailCheck()
    	   {
    	      System.out.println("Mailing a check to " + this.name
    	       + " " + this.address);
    	   }
    	   public String toString()
    	   {
    	      return name + " " + address + " " + number;
    	   }
    	   public String getName()
    	   {
    	      return name;
    	   }
    	   public String getAddress()
    	   {
    	      return address;
    	   }
    	   public void setAddress(String newAddress)
    	   {
    	      address = newAddress;
    	   }
    	   public int getNumber()
    	   {
    	     return number;
    	   }
    }
    

    另外抽象类也可以继承实体类:
    在这里插入图片描述
    在这里插入图片描述
    抽象类中也可以有静态的main方法。
    在这里插入图片描述

    3、答案

    所以接口可以继承接口。抽象类可以实现(implements)接口,抽象类可以继承具体类。抽象类中可以有静态的main方法。

    本文首发于【1024笔记】。搜索关注免费获取海量学习资源
    在这里插入图片描述

    展开全文
  • 抽象类是不是必须要有抽象方法

    千次阅读 2021-08-15 23:57:30
    抽象类除了不能实例化对象之外,类的其它功能依然存在,成员变量、成员方法和构造方法的访问方式和普通类一样。由于抽象不能实例化对象,所以抽象类必须被继承,才能被使用。也是因为这个原因,通常在设计阶段决定...

    在回答这个问题之前,先来了解一下抽象类。

    在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。

    抽象类除了不能实例化对象之外,类的其它功能依然存在,成员变量、成员方法和构造方法的访问方式和普通类一样。由于抽象类不能实例化对象,所以抽象类必须被继承,才能被使用。也是因为这个原因,通常在设计阶段决定要不要设计抽象类。父类包含了子类集合的常见的方法,但是由于父类本身是抽象的,所以不能使用这些方法。

    在 Java 中抽象类表示的是一种继承关系,一个类只能继承一个抽象类,而一个类却可以实现多个接口。(菜鸟教程)

    抽象方法只包含一个方法名,而没有方法体。

    先定义一个抽象类

    public abstract class Student {
        private String name;
        private int age;
    
         public Student(){};
    
        public Student(String name,int age,String adrees){
            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;
        }
        
        }
    
    

    当尝试new对象的时候,会出现以下错误。
    在这里插入图片描述
    我们定义一个pupil类继承Student,并且new个对象

    public class pupil extends Student{
    
        private String name;
        private int age;
        
        public pupil(String name, int age) {//子类在调用父类时 无论自己有没有构造方法都会先去执行父类无参的函数,或者显示调用父类的有参构造函数          
            super(name, age); 
        }
        
        public static void main(String[] args) {
            pupil p = new pupil("ma", 12);
             p.setAge(18); //调用的是父类的方法
            System.out.println(p.getAge()); //18
        }
    }
    

    实例化一个 pupil类对象,该对象将从 Student类继承 7 个成员方法,且通过该方法可以设置或获取两个成员变量。
    我们在Student里面新增一个抽象方法

    public abstract void Shuchu();
    

    继承Student的pupil必须实现父类的抽象方法。

    @Override
        public void Shuchu() {
            System.out.println(name+age);
        }
    

    这里要注意,如果构造方法走的是父类的,那么打印出来的值将为空,因为值赋值给了父类的变量,pupil里面的变量值还是空的。

    总结以上,抽象类并不是一定需要抽象方法,但是一个类拥有抽象方法,那么这个类必须是抽象类,子类必须实现父类的抽象方法,或者子类本身也为抽象类,抽象类绝对不能用来初始化对象。

    1. 抽象类不能被实例化(初学者很容易犯的错),如果被实例化,就会报错,编译无法通过。只有抽象类的非抽象子类可以创建对象。

    2. 抽象类中不一定包含抽象方法,但是有抽象方法的类必定是抽象类。

    3. 抽象类中的抽象方法只是声明,不包含方法体,就是不给出方法的具体实现也就是方法的具体功能。

    4. 构造方法,类方法(用 static 修饰的方法)不能声明为抽象方法。

    5. 抽象类的子类必须给出抽象类中的抽象方法的具体实现,除非该子类也是抽象类。

    6. 抽象方法需要被实现,不能被声明为静态,private,final修饰

    展开全文
  • java抽象类和抽象方法

    千次阅读 2021-03-07 00:02:17
    一、什么是抽象类和抽象方法没有具体功能的实现,通过子类继承后重写方法实现一定约束的类称之为抽象类,抽象类必须被abstract修饰。抽象方法就是只有方法声明,没有方法体的方法抽象类的使用一般通过继承来实现...

    一、什么是抽象类和抽象方法

    没有具体功能的实现,通过子类继承后重写方法来实现一定约束的类称之为抽象类,抽象类必须被abstract修饰。抽象方法就是只有方法声明,没有方法体的方法。抽象类的使用一般通过继承来实现

    二、为什么需要抽象类和抽象方法

    引用抽象方法和抽象类,是java提供的一种语法工具,引导使用者正确的使用它们,减少误用。相当于对子类进行一定限制。

    三、抽象类和抽象方法的语法规则及其注意事项

    抽象类抽象方法必须被abstract修饰。

    抽象类中可以有普通方法,但是有抽象方法的类必须是抽象类。抽象类中的普通方法因为不能被创建对象,所以不能使用这个普通方法。

    抽象类除了不能实例化对象之外,类的其它功能依然存在。

    抽象方法中可以有被static修饰main方法,并且可以执行。

    一个类在继承抽象类后,必须实现抽象类中定义的所有抽象方法。除非它自己也声明为抽象类。

    抽象方法名后面直接跟一个分号,而不是花括号。

    四、抽象类和抽象方法的实现案例

    1、抽象类中可以有普通方法,但是有抽象方法的类必须是抽象类。

    public abstract class Demo01 {

    public abstract void run();

    public void test(){}

    }

    //编译通过,不报错

    public class Demo01 {

    public abstract void run();

    public void test(){}

    }

    //报错:

    Class 'Demo01' must either be declared abstract or implement abstract method 'run()' in 'Demo01'

    Abstract method in non-abstract class

    2a03c1ce46b001404d74cb483c53dfed.png

    2、抽象类除了不能实例化对象

    public abstract class Demo01 {

    public abstract void run();

    public static void main(String[] args) {

    Demo01 demo01=new Demo01();

    }

    }

    e391d9aa2a3f1229ee45ef3aa8a40ae4.png

    3、抽象方法中可以有被static修饰main方法,并且可以执行。

    public abstract class Demo01 {

    public abstract void run();

    public static void main(String[] args) {

    System.out.println("抽象类中的main方法");

    }

    }

    //输出结果:抽象类中的main方法

    4、抽象类的使用一般通继承来实现,且子类中要么对抽象类的方法进行重写,要么声明子类也为抽象类

    public class Demo02 extends Demo01{

    @Override

    public void run() {

    }

    }

    abstract class Demo03 extends Demo01{

    }

    //Demo02和Demo3均能编译通过。

    5、抽象类中的静态方法可以用类名.方法名的方式调用

    e48ac6d43d5525c72074397ed91e40cc.png

    6、抽象的实例:

    有抽象类Father,和抽象方法run()。

    public abstract class Father {

    private String name;

    private int age;

    private char sex='男';

    public int money=100_000;

    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 char getSex() {

    return sex;

    }

    public void setSex(char sex) {

    this.sex = sex;

    }

    abstract void run();

    public void say(){

    System.out.println("这是父类普通方法");

    }

    public static void go(){

    System.out.println("这是父类静态方法");

    }

    }

    有子类Son继承了抽象类,重写了父类的抽象方法run

    public class Son extends Father{

    private double salary;

    @Override

    void run() {

    System.out.println("子类重写了父类的方法run");

    System.out.println(super.getSex());

    super.say();

    }

    public static void main(String[] args) {

    Son son=new Son();

    son.run();

    System.out.println(son.getSex());

    //System.out.println(super.getSex()); //错误

    son.setAge(47);

    System.out.println(son.getAge());

    son.setName("ThreePure");

    System.out.println(son.getName());

    //调用父类的公有属性

    System.out.println(son.money);

    //使用继承于父类的方法

    son.say();

    }

    }

    运行结果:

    子类重写了父类的方法run

    这是父类普通方法

    47

    ThreePure

    100000

    这是父类普通方法

    尽管我们不能实例化一个 Father类的对象,但是如果我们实例化一个 Son 类对象,该对象将从 Father 类继承 成员方法,且通过该方法可以设置或获取成员变量。

    五、抽象类的其他补充吗

    抽象类是否有构造器:

    e4dc66d994535459d7bdc270574d7b1e.png

    从图中我们可以知道抽象类也是有构造器的,并别在子类创建对象时被调用。

    public abstract class Demo3 {

    public Demo3() {

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

    }

    }

    public class Demo4 extends Demo3{

    public static void main(String[] args) {

    Demo4 demo4 =new Demo4();

    }

    }

    //抽象类的构造方法

    2、final与abstract的矛盾

    final关键字可以修饰类、方法、变量。final修饰的类不能被派生;final修饰的方法,禁止子类重写。所以我们可以看出,final和abstract不能一起使用。

    3、构造方法,类方法(用 static 修饰的方法)不能声明为抽象方法。

    ef1db7eeaea5b0eb959f00a80b959e63.png

    展开全文
  • 抽象方法没有方法

    千次阅读 2021-01-30 21:26:33
    抽象方法在父类中不能实现,所以没有方法体。 // 这就是一个抽象类 abstract class Animal { // 动物会叫 public abstract void cry(); // 确定动物怎么叫的。...但在后续在继承时,要具体实现方法。 } ...
  • 能不能有些抽象方法不实现?  分享| 2015-05-27 21:22忆晨儿 | 浏览 1161 次 来自:手机知道  java 2015-05-27 21:32 #2016年高质量新标准全面升级!# 提问者采纳 凡是实现...
  • 首先,父类一个抽象方法,并且在自身的其他方法中调用了 public abstract class Baba { public abstract void say...父类 baba,一个say抽象方法,没有实现,并且在dosomething中调用了。如果直接调用dosomethi...
  • 目录1. 如何调用抽象类中的抽象方法?2. 如何调用接口中的抽象方法? 1. 如何调用抽象类中的抽象方法? 2. 如何调用接口中的抽象方法
  • 抽象类也可以有实现体的方法

    千次阅读 2015-10-16 16:02:00
    2019独角兽企业重金招聘Python工程师标准>>> ...抽象类也可以拥有具体实现了的方法,只是不能直接实例化(不能直接new 抽象方法); 转载于:https://my.oschina.net/craftsdream/blog/518074
  • 上一篇说了java中多个子类实现同一个接口,怎么区分调的是哪一个...Son,Son2是他的子类,一个talk方法具体实现。 那么可以Father f =new Son();这里不能new Father,抽象类无法实例化,而f.talk();调用的是Son的t
  • 接口是一个特殊的抽象类,里面只能有抽象方法 接口使用interface定义 接口里面的抽象方法不用使用abstract定义 子类通过关键字implements去实现接口,必须把接口的抽象方法全部实现出来 一个子类可以实现多个端口...
  • 抽象类为什么不能创建对象?

    千次阅读 2020-07-10 17:24:06
    在java中,含有抽象方法的类称为抽象类,同样不能生成对象。 抽象类是完整的,它只能用作基类。在面向对象方法中,抽象类主要用来进行类型隐藏和充当全局变量的角色。 通过上面的阐述,大家应该对抽象了一...
  • C#中抽象类与抽象方法的详解

    万次阅读 2020-06-17 17:41:11
    抽象类的含义是什么? 抽象类怎么创建? 抽象类的规则哪些? 抽象方法? 抽象类被运用的意义是什么?
  • 抽象实现某个接口

    千次阅读 2021-11-26 10:15:36
    /** * created by wlx on 2021/11/26 ...抽象类没有实现接口的方法 public abstract class Test implements Itest{ } 子类需实现接口的全部方法,否则报错 public class Testapp extends Test{ @Overri...
  • 接口中只能定义常量和抽象方法,对。在Java语言中,接口是一个抽象类型,是抽象方法的集合,通常以关键字interface来声明。一个类通过继承接口的方式,从而来继承接口的抽象方法。接口中只能定义常量和抽象方法,对...
  • C#抽象类和抽象方法(很详细,你值得拥有!!!)

    千次阅读 多人点赞 2020-06-18 19:10:32
    什么是抽象类? 什么是抽象方法? 抽象类和抽象方法有什么特性? 抽象类的使用场景? 抽象类的作用? 抽象类和接口的区别? 抽象类和抽象方法怎么声明? 抽象类和抽象方法如何使用?
  • java抽象方法怎么写

    千次阅读 2021-02-13 00:44:13
    1. java中什么叫抽象方法抽象类及他们的特点,说的具体些,写个例子7.何为抽象方法抽象类?马 克 -to -win:方法个abstract修饰符,就叫抽象方法。类前个abstract修饰符就是抽象类,完了,简单就好记。以下...
  • 今天我们谈谈为什么抽象类中不能有静态的抽象方法以及static修饰的方法不能被重写可以被继承 1 static修饰的方法不能被重写可以被继承 我们知道static修饰的方法为静态方法,可以直接使用类名.方法名进行调用...
  • 抽象不能继承接口

    千次阅读 2017-09-21 10:21:43
    1. 抽象类可以继承普通类,但可以继承接口。 (public abstract class 抽象类 extends 普通类 { }) 2. 接口可以继承多接口,但可以继承抽象类。...3. 抽象类可以实现单接口。(public abstract class 抽象类...
  • 接口、抽象类和实现

    千次阅读 2019-04-13 10:49:25
    2. 接口被类(抽象类和具体类)实现,区别在于抽象实现接口,可以实现该接口的方法,也可以不实现该接口的方法具体类必须实现接口的所有方法 3. 接口可以被接口继承,但允许被类继承 4. 类之间可以相互继承...
  • 抽象类和抽象方法定义及讲解?

    千次阅读 多人点赞 2019-02-26 17:26:23
    (1)抽象类只能作为其他类的基类,它不能直接实例化,对抽象不能使用new 操作符。 (2)抽象类中可以包含抽象成员,但非抽象类中可以。 (3)如果一个非抽象类从抽象类中派生,则其必须通过覆盖来实现所有...
  • java抽象类的构造方法和普通类的构造方法一样都是用来初始化类只是抽象类的构造方法不能直接调用 因为抽象不能实现实例但是一旦一个普通类继承了抽象类 便也可以在构造函数中调用其抽象类的构造函数也可以使用其...
  • Java抽象不能创建对象

    万次阅读 2017-03-06 14:35:21
    抽象类和接口都创建对象,只是后边的new不能是new他们自己,但可以new他们的实现类(必须是类,不能抽象类和接口), 人们使用抽象类和接口只是为了说明要干什么事,而让他们的实现类去根据自己的需要去实现这些...
  • 如下代码,想得到这样结果execute AA before execute..C execute AA after 应该怎么处理 public class Test { public static void main(String[] args) { C c = new C(); c.A(); } } interface YY { ...
  • Java抽象类/抽象方法定义及其特性详解

    千次阅读 多人点赞 2019-09-28 18:37:53
    定义抽象类的作用是将一类对象的共同特点抽象出来,成为代表该类共同特性的抽象概念,其后在描述某一具体对象时,只要添加与其他子类对象的不同之处,而需要重复类的共同特性。这样就使得程序概念层次分明,开发更...
  • java:抽象的两种实现方式(抽象类和接口)及其比较

    千次阅读 多人点赞 2018-02-23 20:57:38
    对于面向对象编程来说,抽象是它的一大特征之一。在Java中,可以通过两种形式来体现面向对象的编程(OOP)的抽象...抽象方法是一种特殊的方法:它只有声明,而没有具体实现抽象方法的声明格式为: abstract v...
  • Java抽象类为什么不能被实例化?

    千次阅读 2020-07-08 22:25:23
    抽象类是Java中一种特殊的类,该类使用了abstract关键字进行修饰,该类允许普通方法抽象方法,该类能够进行实例化(这个在后面进行解释)因为抽象不能直接实例化,所以必须需要有实现子类。 问题二:为什么...
  • 抽象类为什么不能被实例化?

    千次阅读 多人点赞 2019-12-04 21:54:39
    今天无意中看到一个问题:为什么抽象不能实例化? 很多人的答案都是再说使用抽象类的好处,但是并没有回答为什么不能实例化?这个过程就像是在回答:为什么公鸡不能下蛋?然后回答是使用公鸡可以打鸣。 按照我的...
  • Java中抽象类与方法的重写

    千次阅读 2020-11-10 22:29:33
    总结:父类中的功能是不能删除的,但其形式是需要的(没有存在的意义),此时就可以将父类中功能的 具体实现 形式 给删掉; 类的具体实现:创建对象 抽象方法存在的意义是什么? 用于定义功能,明确该类具备此功能...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 821,395
精华内容 328,558
关键字:

抽象方法不能有具体的实现