精华内容
下载资源
问答
  • Java抽象

    2018-05-16 21:55:34
    1.什么是抽象方法?抽象方法的关键字是:abstract抽象方法中没有方法体。抽象方法必须放到抽象类中。2.什么是抽象类?1.有抽象方法的类。2.关键字是:abstract抽象类不可实例化。继承一个抽象类必须要实现抽象类中的...

    1.什么是抽象方法?

    抽象方法的关键字是:abstract

    抽象方法中没有方法体。

    抽象方法必须放到抽象类中。








    2.什么是抽象类?

    1.有抽象方法的类。

    2.关键字是:abstract

    抽象类不可实例化。

    继承一个抽象类必须要实现抽象类中的抽象方法。

    除非子类也是抽象类

    3.抽象类的好处是什么?

    是一个模板或约束,避免了子类的随意性,需要实现它的类必须重写它的抽象方法

    展开全文
  • Java抽象类 详解

    万次阅读 多人点赞 2016-10-05 00:06:35
    一、抽象类的基本概念普通类是一个完善的功能类,可以直接产生实例化对象,并且在普通类中可以包含有构造方法、普通方法、static方法、常量和变量等内容。而抽象类是指在普通类的结构里面增加抽象方法的组成部分。...

    一、抽象类的基本概念

    普通类是一个完善的功能类,可以直接产生实例化对象,并且在普通类中可以包含有构造方法、普通方法、static方法、常量和变量等内容。而抽象类是指在普通类的结构里面增加抽象方法的组成部分。

    那么什么叫抽象方法呢?在所有的普通方法上面都会有一个“{}”,这个表示方法体,有方法体的方法一定可以被对象直接使用。而抽象方法,是指没有方法体的方法,同时抽象方法还必须使用关键字abstract做修饰

    拥有抽象方法的类就是抽象类,抽象类要使用abstract关键字声明。

    范例:定义一个抽象类

    abstract class A{//定义一个抽象类
    	
    	public void fun(){//普通方法
    		System.out.println("存在方法体的方法");
    	}
    	
    	public abstract void print();//抽象方法,没有方法体,有abstract关键字做修饰
    	
    }
    

    二、抽象类的使用

    我们先看范例。
    范例:直接实例化抽象类的对象

    package com.wz.abstractdemo;
    
    abstract class A{//定义一个抽象类
    	
    	public void fun(){//普通方法
    		System.out.println("存在方法体的方法");
    	}
    	
    	public abstract void print();//抽象方法,没有方法体,有abstract关键字做修饰
    	
    }
    
    public class TestDemo {
    
    	public static void main(String[] args) {
    		A a = new A();
    	}
    }
    

    运行:

    Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
    	Cannot instantiate the type A
    
    	at com.wz.abstractdemo.TestDemo.main(TestDemo.java:15)
    
    

    从上可知,A是抽象的,无法直接进行实例化操作。为什么不能直接实例化呢?当一个类实例化之后,就意味着这个对象可以调用类中的属性或者放过了,但在抽象类里存在抽象方法,而抽象方法没有方法体,没有方法体就无法进行调用。既然无法进行方法调用的话,又怎么去产生实例化对象呢。

    抽象类的使用原则如下:
    (1)抽象方法必须为public或者protected(因为如果为private,则不能被子类继承,子类便无法实现该方法),缺省情况下默认为public;
    (2)抽象类不能直接实例化,需要依靠子类采用向上转型的方式处理;
    (3)抽象类必须有子类,使用extends继承,一个子类只能继承一个抽象类;
    (4)子类(如果不是抽象类)则必须覆写抽象类之中的全部抽象方法(如果子类没有实现父类的抽象方法,则必须将子类也定义为为abstract类。);

    范例:

    package com.wz.abstractdemo;
    
    abstract class A{//定义一个抽象类
    	
    	public void fun(){//普通方法
    		System.out.println("存在方法体的方法");
    	}
    	
    	public abstract void print();//抽象方法,没有方法体,有abstract关键字做修饰
    	
    }
    //单继承
    class B extends A{//B类是抽象类的子类,是一个普通类
    
    	@Override
    	public void print() {//强制要求覆写
    		System.out.println("Hello World !");
    	}
    	
    }
    public class TestDemo {
    
    	public static void main(String[] args) {
    		A a = new B();//向上转型
    		
    		a.print();//被子类所覆写的过的方法
    	}
    }
    
    

    运行结果:

    Hello World !
    
    

    现在就可以清楚的发现:
    (1)抽象类继承子类里面有明确的方法覆写要求,而普通类可以有选择性的来决定是否需要覆写;
    (2)抽象类实际上就比普通类多了一些抽象方法而已,其他组成部分和普通类完全一样;
    (3)普通类对象可以直接实例化,但抽象类的对象必须经过向上转型之后才可以得到。

    虽然一个类的子类可以去继承任意的一个普通类,可是从开发的实际要求来讲,普通类尽量不要去继承另外一个普通类,而是去继承抽象类。

    三、抽象类的使用限制

    (1)抽象类中有构造方法么?
    由于抽象类里会存在一些属性,那么抽象类中一定存在构造方法,其存在目的是为了属性的初始化。
    并且子类对象实例化的时候,依然满足先执行父类构造,再执行子类构造的顺序。

    范例如下:

    package com.wz.abstractdemo;
    
    abstract class A{//定义一个抽象类
    	
    	public A(){
    		System.out.println("*****A类构造方法*****");
    	}
    
    	public abstract void print();//抽象方法,没有方法体,有abstract关键字做修饰
    	
    }
    //单继承
    class B extends A{//B类是抽象类的子类,是一个普通类
    
    	public B(){
    		System.out.println("*****B类构造方法*****");
    	}
    	
    	@Override
    	public void print() {//强制要求覆写
    		System.out.println("Hello World !");
    	}
    	
    }
    public class TestDemo {
    
    	public static void main(String[] args) {
    		A a = new B();//向上转型
    	}
    
    }
    
    

    执行结果:

    *****A类构造方法*****
    *****B类构造方法*****
    

    (2)抽象类可以用final声明么?
    不能,因为抽象类必须有子类,而final定义的类不能有子类;

    (3)抽象类能否使用static声明?
    先看一个关于外部抽象类的范例:

    package com.wz.abstractdemo;
    
    static abstract class A{//定义一个抽象类
    	
    	public abstract void print();
    	
    }
    
    class B extends A{
    	
    	public void print(){
    		System.out.println("**********");
    	}
    }
    public class TestDemo {
    
    	public static void main(String[] args) {
    		A a = new B();//向上转型
    		a.print();
    	}
    
    }
    
    

    执行结果

    Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
    	Illegal modifier for the class A; only public, abstract & final are permitted
    
    	at com.wz.abstractdemo.A.<init>(TestDemo.java:3)
    	at com.wz.abstractdemo.B.<init>(TestDemo.java:9)
    	at com.wz.abstractdemo.TestDemo.main(TestDemo.java:18)
    
    

    再看一个关于内部抽象类:

    package com.wz.abstractdemo;
    
    abstract class A{//定义一个抽象类
    	
    	static abstract class B{//static定义的内部类属于外部类
    		public abstract void print();
    	}
    	
    }
    
    class C extends A.B{
    	
    	public void print(){
    		System.out.println("**********");
    	}
    }
    public class TestDemo {
    
    	public static void main(String[] args) {
    		A.B ab = new C();//向上转型
    		ab.print();
    	}
    
    }
    
    

    执行结果:

    **********
    

    由此可见,外部抽象类不允许使用static声明,而内部的抽象类运行使用static声明。使用static声明的内部抽象类相当于一个外部抽象类,继承的时候使用“外部类.内部类”的形式表示类名称。

    (4)可以直接调用抽象类中用static声明的方法么?
    任何时候,如果要执行类中的static方法的时候,都可以在没有对象的情况下直接调用,对于抽象类也一样。
    范例如下:

    package com.wz.abstractdemo;
    
    abstract class A{//定义一个抽象类
    	
    	public static void print(){
    		System.out.println("Hello World !");
    	}
    	
    }
    
    public class TestDemo {
    
    	public static void main(String[] args) {
    		A.print();
    	}
    
    }
    
    

    运行结果:

    Hello World !
    
    

    (5)有时候由于抽象类中只需要一个特定的系统子类操作,所以可以忽略掉外部子类。这样的设计在系统类库中会比较常见,目的是对用户隐藏不需要知道的子类。
    范例如下:

    package com.wz.abstractdemo;
    
    abstract class A{//定义一个抽象类
    	public abstract void print();
    	
    	private static class B extends A{//内部抽象类子类
    		
    		public void print(){//覆写抽象类的方法
    			System.out.println("Hello World !");
    		}
    	}
    	
    	//这个方法不受实例化对象的控制
    	public static A getInstance(){
    		return new B();
    	}
    	
    }
    
    public class TestDemo {
    
    	public static void main(String[] args) {
    		
    		//此时取得抽象类对象的时候完全不需要知道B类这个子类的存在
    		A a = A.getInstance();
    		a.print();
    	}
    }
    
    

    运行结果:

    Hello World !
    

    四、抽象类的应用——模板设计模式

    例如,现在有三类事物:
    (1)机器人:充电,工作;
    (2)人:吃饭,工作,睡觉;
    (3)猪:进食,睡觉。
    现要求实现一个程序,可以实现三种不同事物的行为。

    先定义一个抽象行为类:

    package com.wz.abstractdemo;
    
    public abstract class Action{
    	
    	public static final int EAT = 1 ;
    	public static final int SLEEP = 3 ;
    	public static final int WORK = 5 ;
    	
    	public abstract void eat();
    	public abstract void sleep();
    	public abstract void work();
    	
    	public void commond(int flags){
    	  switch(flags){
    		case EAT:
    			this.eat();
    			break;
    		case SLEEP:
    			this.sleep();
    			break;
    		case WORK:
    			this.work();
    			break;
    		case EAT + SLEEP:
    			this.eat();
    			this.sleep();
    			break;
    		case SLEEP + WORK:
    			this.sleep();
    			this.work();
    			break;
    		default:
    			break;
    		}
    	}
    }
    
    

    定义一个机器人的类:

    package com.wz.abstractdemo;
    
    public class Robot extends Action{
    
    	@Override
    	public void eat() {
    		System.out.println("机器人充电");
    		
    	}
    
    	@Override
    	public void sleep() {
    		
    	}
    
    	@Override
    	public void work() {
    		System.out.println("机器人工作");
    		
    	}
    	
    }
    
    
    

    定义一个人的类:

    package com.wz.abstractdemo;
    
    public class Human extends Action{
    
    	@Override
    	public void eat() {
    		System.out.println("人吃饭");
    		
    	}
    
    	@Override
    	public void sleep() {
    		System.out.println("人睡觉");
    		
    	}
    
    	@Override
    	public void work() {
    		System.out.println("人工作");
    		
    	}
    	
    }
    

    定义一个猪的类:

    package com.wz.abstractdemo;
    
    public class Pig extends Action{
    
    	@Override
    	public void eat() {
    		System.out.println("猪进食");
    		
    	}
    
    	@Override
    	public void sleep() {
    		System.out.println("猪睡觉");
    		
    	}
    
    	@Override
    	public void work() {
    		
    		
    	}
    	
    }
    
    

    测试主类:

    package com.wz.abstractdemo;
    
    public class AbstractDemo {
    
    	public static void main(String[] args) {
    		
    		fun(new Robot());
    		
    		fun(new Human());
    		
    		fun(new Pig());
    
    	}
    	
    	public static void fun(Action act){
    		act.commond(Action.EAT);
    		act.commond(Action.SLEEP);
    		act.commond(Action.WORK);
    	}
    
    }
    
    

    运行结果:

    机器人充电
    机器人工作
    人吃饭
    人睡觉
    人工作
    猪进食
    猪睡觉
    
    

    所有的子类如果要想正常的完成操作,必须按照指定的方法进行覆写才可以,而这个时候抽象类所起的功能就是一个类定义模板的功能。

    展开全文
  • java抽象

    千次阅读 2018-11-14 11:24:48
    java抽象

    分享一下我老师大神的人工智能教程!零基础,通俗易懂!http://blog.csdn.net/jiangjunshow

    也欢迎大家转载本篇文章。分享知识,造福人民,实现我们中华民族伟大复兴!

                   
    JAVA抽象类的理解:
    1、普通的JAVA类也可以在CLASS前加ABSTRACT声明为抽象,只不过此时的该类不再可以实例化。
    2、如果一个类里有一个以上的抽象方法,则该类必须声明为抽象类,该方法也必须声明为抽象。
    3、抽象类不能被实例化,但不代表它不可以有构造函数,抽象类可以有构造函数,备继承类扩充
    用 abstract 修饰的类是抽象类。
    抽象类是不完整的,并且它只能用作基类。它与非抽象类的不同:   1、抽象类不能直接实例化,并且对抽象类使用 new 运算符是编译时错误。虽然一些变量和值在编译时的类型可以是抽象的,但是这样的变量和值必须或者为 null,或者含有对非抽象类的实例的引用(此非抽象类是从抽象类派生的)。   2、允许(但不要求)抽象类包含抽象成员。   3、抽象类不能被密封。   当Congo抽象类派生非抽象类时,这些非抽象类必须具体实现所继承的所有抽象成员,从而重写哪些抽象成员。在下边的示例中:    abstract class A{ public abstract void F();}   abstract class B: A{ public void G() {}}   class C: B{ public override void F() { // actual implementation of F }}    抽象类 A 引入抽象方法 F。类 B 引入另一个方法 G,但由于它不提供 F 的实现,B 也必须声明为抽象类。类 C 重写 F,并提供一个具体实现。由于 C 中没有了抽象成员,因此可以(但并非必须)将 C 声明为非抽象类。   抽象类与接口紧密相关。然接口又比抽象类更抽象,这主要体现在它们的差别上:1)类可以实现无限个接口,但仅能从一个抽象(或任何其他类型)类继承,从抽象类派生的类仍可实现接口,从而得出接口是用来解决多重继承问题的。2)抽象类当中可以存在非抽象的方法,可接口不能且它里面的方法只是一个声明必须用public来修饰没有具体实现的方法。3)抽象类中的成员变量可以被不同的修饰符来修饰,可接口中的成员变量默认的都是静态常量(static final)。4)这一点也是最重要的一点本质的一点"抽象类是对象的抽象,然接口是一种行为规范"。   以上是它们本身的异同,下面再来从实际应用讲讲它们的异同!   不同之处:

    定义  抽象类表示该类中可能已经有一些方法的具体定义,但是接口就仅仅只能定义各个方法的界面(方法名,参数列表,返回类型),并不关心具体细节。

    用法  1)在继承抽象类时,必须覆盖该类中的每一个抽象方法,而每个已实现的方法必须和抽象类中指定的方法一样,接收相同数目和类型的参数,具有同样的返回值,这一点与接口相同。   2)当父类已有实际功能的方法时,该方法在子类中可以不必实现,直接引用的方法,子类也可以重写该父类的方法(继承的概念)。   3)而实现 (implement)一个接口(interface)的时候,是一定要实现接口中所定义的所有方法,而不可遗漏任何一个。   4)另外,抽象类不能产生对象的,但可以由它的实现类来声明对象。   有鉴于此,在实现接口时,我们也常写一个抽象类,来实现接口中的某些子类所需的通用方法,接着在编写各个子类时,即可继承该抽象类来使用,省去在每个都要实现通用的方法的困扰。
               

    给我老师的人工智能教程打call!http://blog.csdn.net/jiangjunshow

    这里写图片描述
    展开全文
  • Java 抽象

    千次阅读 多人点赞 2019-01-28 09:16:52
    Java 抽象类 在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。 抽象类除了不能实例...

    Java 抽象类

    在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。
    抽象类除了不能实例化对象之外,类的其它功能依然存在,成员变量、成员方法和构造方法的访问方式和普通类一样。
    由于抽象类不能实例化对象,所以抽象类必须被继承,才能被使用。也是因为这个原因,通常在设计阶段决定要不要设计抽象类。
    父类包含了子类集合的常见的方法,但是由于父类本身是抽象的,所以不能使用这些方法。
    在Java中抽象类表示的是一种继承关系,一个类只能继承一个抽象类,而一个类却可以实现多个接口。
    抽象类
    在Java语言中使用abstract class来定义抽象类。如下实例:

    Employee.java 文件代码:
    /* 文件名 : Employee.java */

    public abstract class Employee
    {
       private String name;
       private String address;
       private int number;
       public Employee(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;
       }
    }
    
    注意到该 Employee 类没有什么不同,尽管该类是抽象类,但是它仍然有 3 个成员变量,7 个成员方法和 1 个构造方法。 现在如果你尝试如下的例子:

    AbstractDemo.java 文件代码:
    /* 文件名 : AbstractDemo.java */

    public class AbstractDemo
    {
       public static void main(String [] args)
       {
          /* 以下是不允许的,会引发错误 */
          Employee e = new Employee("George W.", "Houston, TX", 43);
     
          System.out.println("\n Call mailCheck using Employee reference--");
          e.mailCheck();
        }
    }
    
    当你尝试编译AbstractDemo类时,会产生如下错误:
    Employee.java:46: Employee is abstract; cannot be instantiated
          Employee e = new Employee("George W.", "Houston, TX", 43);
                       ^
    1 error
    
    继承抽象类
    我们能通过一般的方法继承Employee类:

    Salary.java 文件代码:
    /* 文件名 : Salary.java */

    public class Salary extends Employee
    {
       private double salary; //Annual salary
       public Salary(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;
       }
    }
    
    尽管我们不能实例化一个 Employee 类的对象,但是如果我们实例化一个 Salary 类对象,该对象将从 Employee 类继承 7 个成员方法,且通过该方法可以设置或获取三个成员变量。

    AbstractDemo.java 文件代码:
    /* 文件名 : AbstractDemo.java */

    public class AbstractDemo
    {
       public static void main(String [] args)
       {
          Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
          Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
     
          System.out.println("Call mailCheck using Salary reference --");
          s.mailCheck();
     
          System.out.println("\n Call mailCheck using Employee reference--");
          e.mailCheck();
        }
    }
    
    以上程序编译运行结果如下:
    Constructing an Employee
    Constructing an Employee
    Call mailCheck using  Salary reference --
    Within mailCheck of Salary class
    Mailing check to Mohd Mohtashim with salary 3600.0
    
    Call mailCheck using Employee reference--
    Within mailCheck of Salary class
    Mailing check to John Adams with salary 2400.
    
    抽象方法
    如果你想设计这样一个类,该类包含一个特别的成员方法,该方法的具体实现由它的子类确定,那么你可以在父类中声明该方法为抽象方法。
    Abstract 关键字同样可以用来声明抽象方法,抽象方法只包含一个方法名,而没有方法体。
    抽象方法没有定义,方法名后面直接跟一个分号,而不是花括号。
    public abstract class Employee
    {
       private String name;
       private String address;
       private int number;
       
       public abstract double computePay();
       
       //其余代码
    }
    
    声明抽象方法会造成以下两个结果:
    如果一个类包含抽象方法,那么该类必须是抽象类。
    任何子类必须重写父类的抽象方法,或者声明自身为抽象类。
    继承抽象方法的子类必须重写该方法。否则,该子类也必须声明为抽象类。最终,必须有子类实现该抽象方法,否则,从最初的父类到最终的子类都不能用来实例化对象。
    如果Salary类继承了Employee类,那么它必须实现computePay()方法:

    Salary.java 文件代码:
    /* 文件名 : Salary.java */

    public class Salary extends Employee
    {
       private double salary; // Annual salary
      
       public double computePay()
       {
          System.out.println("Computing salary pay for " + getName());
          return salary/52;
       }
     
       //其余代码
    }
    

    抽象类总结规定:

    1. 抽象类不能被实例化(初学者很容易犯的错),如果被实例化,就会报错,编译无法通过。只有抽象类的非抽象子类可以创建对象。
    2. 抽象类中不一定包含抽象方法,但是有抽象方法的类必定是抽象类。
    3. 抽象类中的抽象方法只是声明,不包含方法体,就是不给出方法的具体实现也就是方法的具体功能。
    4. 构造方法,类方法(用 static 修饰的方法)不能声明为抽象方法。
    5. 抽象类的子类必须给出抽象类中的抽象方法的具体实现,除非该子类也是抽象类。
    展开全文
  • java 抽象

    千次阅读 2020-02-07 10:40:58
    1.java抽象类的基本概念 普通类就是完善的功能类,直接生产对象并使用,其中的方法都已经实现完整(带有方法体"{}").抽象类的最大特点包含了抽象方法,抽象方法是只声明(没有方法体)的方法,抽象方法定义时使用abstract...
  • java基础-java抽象

    2017-06-20 19:01:42
    java抽象类 (1)基本属性 java抽象类中不一定抽象方法,但是有抽象方法的类一定是java 抽象类;抽象类的抽象方法必须使用abstract修饰;抽象类不可以被实例化,需要依靠继承该抽象类的子类来完成实例化操作. (2)...
  • Java抽象类和抽象方法例子

    千次阅读 2017-09-17 23:56:59
    转自Java抽象类用法示例详解  Java抽象类的定:java抽象类体现数据抽象的思想,是实现程序多态性的一种手段。也提到抽象类与抽象方法的限制,下面我们会通过一下java抽象类小示例来给你介绍抽象类的用法。希望对你...
  • java抽象类详解

    千次阅读 2018-06-27 10:55:13
    1、Java抽象类存在的意义,为什么要使用抽象类? 利于代码的维护和复用。把相同的方法或者属性抽象出来放在一个抽象类中,让类去继承,则实现了复用。 2、什么是抽象类? 加上abstract关键字的类即为抽象类。 3、...
  • Java接口和Java抽象

    2013-04-23 08:36:36
    Java接口和Java抽象类有太多相似的地方,又有太多特别的地方,究竟在什么地方,才是它们的最佳位置呢?把它们比较一下,你就可以发现了。 1、Java接口和Java抽象类最大的一个区别,就在于Java抽象类可以提供某些...
  • Java抽象类和抽象方法详解

    千次阅读 2018-02-24 02:03:51
    Java抽象类和抽象方法详解一 . 由来 当编写一个类时,常常会给这个类定义一些方法来描述这个类的行为方式,通常这些方法都有相应的具体的方法体,但是,在某些情况下,某个基类只是知道其子类应该包含怎样的方法,...
  • Java抽象语法树AST浅析与使用

    万次阅读 2019-10-30 10:51:02
    Java抽象语法树AST浅析与使用概述作用Java项目模型对象AST模型对象AST试图具体使用 概述 抽象语法树(Abstract Syntax Tree, AST)是源代码语法结构的一种抽象表示。它以树状的形式表现编程语言的结构,树的每个节点...
  • Java抽象类用法示例详解

    千次阅读 2016-01-09 18:56:48
    转自Java抽象类用法示例详解 Java抽象类的定:java抽象类体现数据抽象的思想,是实现程序多态性的一种手段。也提到抽象类与抽象方法的限制,下面我们会通过一下java抽象类小示例来给你介绍抽象类的用法。希望对你...
  • java抽象类 与 接口

    千次阅读 2015-01-12 16:13:39
    Java接口和Java抽象类的认识 很难理解为什么要有接口这个概念,虽说是可以实现所谓的多继承,可一个只有方法名,没有方法体的东西,我实现它又有什么用呢?我从它那什么也得不到,除了一些方法名,我直接在具体类...
  • Java 抽象类经典例子2

    千次阅读 2016-10-18 10:24:47
    Java 抽象类经典例子2目录Java 抽象类经典例子2目录 问题描述 代码块 答案问题描述抽象类的练习 学生案例: 具体类:一般学生 优秀学生 共性:姓名 年龄 年纪 吃饭 差异: 学习内容代码块代码块语法遵循...
  • java抽象类和接口

    千次阅读 2019-05-14 17:34:15
    java抽象类和接口 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 开发工具与关键技术:MyEclipse10 作者:朱海恩 撰写时间: 2019.04.30 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~...
  • Java抽象类的作用和使用

    万次阅读 多人点赞 2017-02-12 21:04:16
    转载自Java抽象类的使用 /* 当多个类中出现相同功能,但是功能主体不同, 这是可以进行向上抽取。这时,只抽取功能定义,而不抽取功能主体。 抽象:看不懂。 抽象类的特点: 1,抽象方法一定在抽象类中。 2,...
  • Java抽象类Animal和Cat

    千次阅读 2018-11-09 13:58:31
    Java抽象类概念 在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。 抽象类除了不...
  • Java 抽象方法

    千次阅读 2018-05-18 08:23:06
    抽象方法:抽象方法是一个模板或约束,避免了子类的随意性,需要实现它的类必须重写...2,继承一个抽象类,必须要实现抽象类中的抽象方法,除非子类也是抽象类[java] view plain copypublic abstract class Fru...
  • Java 抽象类与接口

    2014-10-13 23:21:40
    Java 抽象类与接口的区别 1. lian
  • Java抽象

    千次阅读 多人点赞 2018-06-04 15:49:24
    这句话概括了抽象的概念,而在Java中,你可以只给出方法的定义不去实现方法的具体事物,由子类去根据具体需求来具体实现。这种只给出方法定义而不具体实现的方法被称为抽象方法,抽象方法是没有方法体的,在代码的...
  • java抽象类和普通类的区别 1.抽象类不能被实例化。 2.抽象类可以有构造函数,被继承时子类必须继承父类一个构造方法,抽象方法不能被声明为静态。 3.抽象方法只需申明,而无需实现,抽象类中可以允许普通方法有主体...
  • 标签: java抽象类概念理解抽象类与接口区别抽象类与普通类区别 2017-05-04 16:26 1029人阅读 评论(0) 收藏 举报  分类: Java(17)  版权声明:本文为博主csdn_aiyang原创文章,未经博主...
  • Java接口和Java抽象

    千次阅读 2010-08-23 00:13:00
    在没有好好地研习面向对象设计的设计模式之前,我对Java接口和Java抽象类的认识还是很模糊,很不可理解。刚学Java语言时,就很难理解为什么要有接口这个概念,虽说是可以实现所谓的多继承,可一个只有方法名,没有...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 115,557
精华内容 46,222
关键字:

java抽象

java 订阅