精华内容
下载资源
问答
  • 一、抽象类 定义:在普通类的基础上扩充了一些抽象方法 。...举例:定义一个抽象类抽象类中没有具体实现,因此抽象类不能直接实例化对象 abstract class Person{ private String name;//姓名属性 ...

    一、抽象类

    	定义:在普通类的基础上扩充了一些抽象方法 。
    

    1. 抽象方法:只声明而未实现的方法(没有方法体

    • 所有抽象方法使用abstract定义。同时抽象方法所在的类也要用abstract定义,表示抽象类。
    • 举例:定义一个抽象类:

    抽象类中没有具体实现,因此抽象类不能直接实例化对象

    abstract class Person{
    	private String name;//姓名属性
    	public String getName(){
    		return this.name;
    	}
    	public void setName(String name){
    		this.name = name;
    	}
    	//{}为方法体,所有抽象方法没有方法体{}
    	public abstract void getPersonInfo();//抽象方法
    }	
    

    2.抽象类的使用原则

    (1)抽象类必须有子类(abstract与final不能同时使用)。
    (2)子类覆写抽象类所有的抽象方法(abstract与private不能同时使用)。
    (3)抽象类实例化对象,必须通过子类向上转型来实例化对象(抽象类无法直接实例化对象)。
    final与abstract不能同时使用
    private与abstract不能同时使用

    //抽象类的标准操作,也是常用操作。
    
    abstract class Person{
    	//姓名属性
    	private String name;
    	//普通方法
    	public String getName(){
    		return this.name;
    	}
    	public void setName(String name){
    		this.name=name;
    	}
    	//抽象方法
    	public abstract void getPersonInfo();
    }
    
    //子类继承抽象类
    class Student extends Person{
    	public void getPersonInfo(){
    		System.out.println("I am a student");
    	}
    }	
    
    public class Test{
    	public static void main(String[] args){
    		//实例化子类,向上转型
    		Person per = new Student();	
    		//被子类所覆写的方法
    		per.getPersonInfo();
    	}
    }
    
    运行结果:I am a student
    
    abstract class Person{
        private String name ; // 属性
        public String getName(){ // 普通方法
            return this.name;
        }
        public void setName(String name){
            this.name = name ;
        }
        
        public abstract void getPersonInfo() ; //抽象方法
    
        public static Person getInstance() { //取得A类对象
        	//定义抽象类的子类 (内部类)
            class Student extends Person {  
                public void getPersonInfo() {
                    System.out.println("I am a student");
                }
            }
            return new Student();
        }
    }
    
    public class Test{
        public static void main(String[] args) {
            Person per = Person.getInstance();
            per.getPersonInfo() ; //被子类所覆写的方法
        }
    }
    
    运行结果:I am a student
    

    3.抽象类的相关规定

    (1)抽象类也提供构造方法,并且子类也遵循对象实例化流程:先调用父类构造方法,再调用子类构造方法

    abstract class Person{
    	private String name;
    	public String getName(){
    		return name;
    	}
    	
    	//父类构造方法
    	public Person(){
    		System.out.println("1.**************");
    	}
    
    	//抽象方法
    	public abstract void fun();
    }
    
    class Student extends Person{
    	//子类构造方法
    	public Student(){
    		System.out.println("2.##############");
    	}
    
    	public void fun(){
    		System.out.println("子类继承抽象类");
    	}
    }
    public class Test{
    	public static void main(String[] args){
    		new Student();//先调用父类构造方法,再调用子类构造方法
    	}
    }
    
    运行结果:
    1.**************
    2.##############
    
    //面试题
    
    abstract class Person{
    	public Person(){//3.调用父类构造
    		this.print();//4.调用被子类覆写的方法
    	}
    	public abstract void print();//抽象方法
    }
    
    class Student extends Person{
    	private int num = 100;//此句在对象new成功后才会用到,此句告诉构造方法要将num赋值为100
    	public Student(int num){//2.调用子类实例化对象
    		// super();//3.隐含这一句,实际要先调用父类构造。此时还未执行“将num赋值为100”的操作,就去调用父类构造了。num默认为int的默认值0。
    		//num=100;//此句在构造方法中隐式实现。
    		//总的来说,构造方法会隐藏  给变量的赋值操作。 
    		
    		this.num=num;//7.为类中属性初始化
    	}
    	public void print(){//5.此时子类对象的属性还没有被初始化
    		System.out.println(this.num);//6.输出其对应数据类型的默认值,为0
    	}
    }
    
    public class Test{
    	public static void main(String[] args){
    		//先调用父类构造方法,再调用子类构造方法。调用父类构造后,调用打印方法,输出num的值0。调用子类构造,在内存中完成num赋值为30,但并未调用打印方法,因而只有一个值。
    		new Student(30);//1.实例化子类对象
    	}
    }
    //父类中num=0,子类中num=30。但由于子类中没有调用打印方法,所以只有一个父类的num值,为0。
    运行结果:0
    

    (2)抽象类中可以不定义抽象方法,但仍然无法直接实例化对象。
    在这里插入图片描述
    (3)abstract与final、private不能一起用。

    • final声明的类不允许有子类,而abstract抽象类必须有子类。
    • 抽象方法必须要被覆写,因此不能用private封装。
      (4)抽象类也分为内部抽象类和外部抽象类。
    • 内部抽象类(了解)可以使用static定义来描述外部抽象类
      在这里插入图片描述
      如果此时在外部抽象类中使用static就会出现语法错误,但是内部抽象类允许使用static
    //内部抽象类使用static修饰
    
    abstract class A{//此结果出现几率很低
    	public abstract void printA();
    	static abstract class B{
    		public abstract void printB();
    	}
    }
    class x extends A.B{
    	public void printB(){}
    }
    
    注意:对象实例化的核心步骤
      ①类加载
      ②类对象的空间开辟
      ③类对象中的属性初始化(构造方法)
    
    方法可以重写,属性不能重写。
    
    展开全文
  • 接口是公开的,里面不能有私有的方法或变量,是用于让别人使用的,而抽象类是可以有私有方法或私有变量的, 另外,实现接口的一定要实现接口里定义的所有方法,而实现抽象类可以有选择地重写需要用到的方法,一般的...

    接口是公开的,里面不能有私有的方法或变量,是用于让别人使用的,而抽象类是可以有私有方法或私有变量的,

    另外,实现接口的一定要实现接口里定义的所有方法,而实现抽象类可以有选择地重写需要用到的方法,一般的应用里,最顶级的是接口,然后是抽象类实现接口,最后才到具体类实现。

    还有,接口可以实现多重继承,而一个类只能继承一个超类,但可以通过继承多个接口实现多重继承,接口还有标识(里面没有任何方法,如Remote接口)和数据共享(里面的变量全是常量)的作用.

    1.abstract class 在 Java 语言中表示的是一种继承关系,一个类只能使用一次继承关系。但是,一个类却可以实现多个interface.

    2.在abstract class 中可以有自己的数据成员,也可以有非abstarct的成员方法,而在interface中,只能够有静态的不能被修改的数据成员(也就是必须是 static final的,不过在 interface中一般不定义数据成员),所有的成员方法都是abstract的。

    3.abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"is-a"关系,interface表示的是"like-a"关系。

    4.实现抽象类和接口的类必须实现其中的所有方法。抽象类中可以有非抽象方法。接口中则不能有实现方法。

    5.接口中定义的变量默认是public static final 型,且必须给其初值,所以实现类中不能重新定义,也不能改变其值。

    6.抽象类中的变量默认是 friendly 型,其值可以在子类中重新定义,也可以重新赋值。

    7.接口中的方法默认都是 public,abstract 类型的。

     

    展开全文
  • 抽象类定义

    千次阅读 2017-05-26 15:40:25
    抽象类定义  普通类可以直接产生实例化对象,并且在普通类中可以包含构造方法、普通方法、static 方法、常量、变量的内容。而所谓抽象类就是指在普通类的结构里面增加抽象方法的组成部分,抽象方法指的是没有...
    抽象类定义
           普通类可以直接产生实例化对象,并且在普通类中可以包含构造方法、普通方法、static 方法、常量、变量的内容。而所谓抽象类就是指在普通类的结构里面增加抽象方法的组成部分,抽象方法指的是没有方法体的方法,同时抽象类方法还必须使用abstract关键字定义。拥有抽象方法的类一定属于抽象类,抽象类要使用abstract声明。
    定义抽象类:
    abstract class A{    //定义一个抽象类,使用abstract声明
        public void fun(){  //普通方法
           System.out.println("存在又方法体的方法");  
    //此方法没有方法体的声明,并且存在abstract关键字,表示抽象方法
        public abstract void print();
     }
    }
    在本程序的类中定义了一个抽象方法print(),既然类中有抽象方法,那么类就必须定义为抽象类,所以使用了“abstract class”来定义。但是一定要记住:抽象类只是比普通类多了抽象方法的定义,其他结构与普通类完全一样。

    注意:抽象类不能直接实例化对象

    范例:错误的实例化抽象类的操作。
    public class TestDemo{
        public static void main(String[] args){
           A a = new a();  //A是抽象的,无法实例化
      }
    }

    如果要想使用抽象类,必须遵守如下原则。
    1.抽象类必须有子类,即每一个抽象类一定要被子类所继承(使用extends关键字),但是在“java”中每一个子类只能够继承一个抽象类,所以具备单继承局限;
    2.抽象类的子类(子类不是抽象类)必须覆写抽象类中的全部抽象方法(强制子类覆写);
    3.依靠对象的向上转型概念,可以通过抽象类的子类完成抽象类的实例化对象操作。


    范例:错误的实例化抽象类的操作。
    abstract class A{	//定义一个抽象类,使用abstract声明
    		public void fun(){	//普通方法
    			System.out.println("存在有方法体的方法!");
    	}
    	//此方法并没有方法体的声明,并且存在abstract关键字,表示抽象方法
    	public abstract void print();
    }
    //一个子类只能够继承一个抽象类,属于单继承局限
    class B extends A{   //B类是抽象类的子类,并且是一个普通类
        public void print(){ //强制要求覆写的方法
           System.out.println("Hello World !");
      }    
    }
    
    public class TestDemo{
      public static void main(String[] args){
         A a = new B();  //向上转型
         a.print();          //被子类覆写过的方法
      }
    }

    
    本程序为抽象类定义了一个子类B,而子类B(是一个普通类)必须要覆写抽象类中的全部抽象方法,而在主方法中依靠子类对象的向上转型实现了抽象类A对象的实例化操作,而调用的print()方法由于被子类所覆写,所以最终调用的是在子类B中覆写过的print()方法。

    展开全文
  • 父类和子类的问题困扰了我许久。...假如父类是一个抽象类的情况呢? 考虑下面的抽象类edge。 其中edge没有实现也没有定义ForwordConnetc();方法 假如我们的类有ForwordConnection继承Edge呢? 我...

    父类和子类的问题困扰了我许久。
    相信各位没有学过java课程的孩子也有相同的感受。


    下面给你们介绍一下几个原则:

    1:父类引用子类原则父类引用子类原则

    2.子类引用子类原则。
    2.子类引用子类原则。

    假如父类是一个抽象类的情况呢?

    考虑下面的抽象类edge。
    edge
    其中edge没有实现也没有定义ForwordConnetc();方法
    假如我们的类有ForwordConnection继承Edge呢?
    这里写图片描述
    这里写图片描述

    我们设置一个方法:
    这里写图片描述

    这个方法上面说到过:
    其中edge没有实现也没有定义ForwordConnetc();方法
    来看看调用情况:
    这里写图片描述
    静态检查报错。
    在java中,进行父类重写的静态检查,然后它发现父类没有这个方法,于是报错。
    注意:重载是动态检查。运行的时候才去找。

    说明:
    用父类声明的时候,抽象类也不能越过父类调用子类方法
    我们修改一下:
    这里写图片描述

    这样就好了。
    所以我们总结一下,无论在抽象类还是一般类中,
    上面的原则都成立。

    另外,抽象类有下面的几个特殊的地方~~
    这里写图片描述

    展开全文
  • 抽象类定义?为什么要使用抽象类?

    千次阅读 2018-07-16 20:18:15
    为什么要使用抽象类? 有什么好处? 答案:1 现实中一些父类中的方法没必要写 各个子类中的方法会有所不同 所以没必要在父类中写 2 看被人代码时候会注意这是抽象方法...5 含有抽象方法的类必须定义抽象类 ...
  • Java抽象类 详解

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

    万次阅读 2016-07-15 15:07:34
    3.抽象类中含有抽象方法时,如果子类继承该抽象类,则必须重写该抽象方法 4.抽象类可以有非抽象方法 5.允许(但不要求)抽象类包含抽象成员。 6.抽象类不能被密封。 7.抽象类含有非抽象方法,而且子类继承该...
  • 抽象类

    千次阅读 多人点赞 2020-01-12 21:57:45
    抽象类中不一定有抽象方法,但是有抽象方法的类必须定义抽象类 C.抽象类不能实例化 因为他不是具体的。 抽象类具有构造方法,但是不能实例化。构造方法的作用是什么?子类对父类数据进行初始化 D:抽象的的子类 a:...
  • 可以用一个抽象类定义一个指向该类的指针,但是不能定义或声明对象。 这个中原因就是,定义一个类的对象是,编译器在编译时需要了解类的所有信息以便准确的为要实例化的对象分配内存;由此可见,定义一个类对象是要...
  • 1.定义抽象类Pet(宠物)类,作为基类。 2.类中定义两个私有字段毛色和年龄,定义抽象方法完成宠物的自我介绍功能; 3.定义两个派生类Cat和Dog,再覆写基类抽象方法; 4.定义包含主方法的类MainClass,通过抽象类...
  • 定义抽象类的作用是将一类对象的共同特点抽象出来,成为代表该类共同特性的抽象概念,其后在描述某一具体对象时,只要添加与其他子类对象的不同之处,而不需要重复类的共同特性。这样就使得程序概念层次分明,开发更...
  • 编程语言的三大发展阶段:面向机器语言、面向过程语言、面向对象语言 ; 其中面向对象语言主要体现三个特征:封装性、继承、...2、声明的变量称为对象变量,也简称 对象 ; 3、class 关键字是用来定义类 ; 4、...
  • 抽象类不能实例化,抽象类可以包含普通函数和抽象函数,抽象函数就是只有函数定义没有函数体。显然抽象函数本身也是虚拟的Virtual (只有函数定义 没有函数体实现)  类是一个模板,那么抽象类就是一个不完整的...
  • python 如何定义抽象类和抽象方法

    千次阅读 2020-01-10 13:00:05
    文章目录(一)python 如何定义抽象类和抽象方法(二)python中的多态(三)类的组合 (一)python 如何定义抽象类和抽象方法 在python中类 通过继承metaclass = ABCmeta类来创建抽象类抽象类是包含抽象方法的类,...
  • 抽象类与接口是Java语言中对抽象概念进行定义的两种机制,正是由于他们的存在才赋予java强大的面向对象的能力。他们两者之间对抽象概念的支持有很大的相似,甚至可以互换,但是也有区别。 一、抽象类 我们都知道在...
  • Java笔试面试-抽象类与接口

    万次阅读 多人点赞 2019-09-15 22:29:50
    抽象类 定义:   在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。简单来说,使用...
  • 抽象类: 不能用来定义对象而只作为一种基本类型用作继承的类,称为抽象类,由于它常用作基类,通常称为抽象基类。凡是包含纯虚函数的类都是...虽然抽象类不能定义对象,但是可以定义指向抽象类数据的指针变量。 ...
  • 抽象类、接口

    千次阅读 2019-05-07 20:19:15
    抽象类定义与规则: 1、包含一个抽象方法的类必须是抽象类。 2、抽象类与抽象方法必须用abstract关键字声明。 3、抽象方法只需声明不需实现。 4、抽象类必须被继承,如果子类不是抽象类必须覆写抽象类的全部抽象方法...
  • 新手小白学JAVA 抽象类

    万次阅读 多人点赞 2021-05-11 11:01:52
    Java中可以定义被abstract关键字修饰的类,被abstract关键字修饰的类叫做抽象类 如果一个类含有抽象方法,那么它一定是抽象类 抽象类中的方法实现交给子类来完成 3.2 抽象方法的格式 权限修饰符 abstract 返回值类型 ...
  • Java 抽象类

    千次阅读 多人点赞 2019-01-28 09:16:52
    抽象类除了不能实例化对象之外,类的其它功能依然存在,成员变量、成员方法和构造方法的访问方式和普通类一样。 由于抽象类不能实例化对象,所以抽象类必须被继承,才能被使用。也是因为这个原因,通常在设计阶段...
  • Java中为何要定义抽象类

    千次阅读 2016-10-19 10:48:45
    抽象类不可以实例化,即使一个类中没有抽象方法,也可以将其定义抽象类,同样,该类不可以实例化。 抽象类的意义: 1,为子类提供一个公共的类型; 2,封装子类中重复内容(成员变量和方法); 3,...
  • 抽象类和接口的区别以及抽象类和接口的使用场景

    千次阅读 多人点赞 2019-05-30 18:15:44
    一、抽象类 在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就可以称之为抽象类。 1.抽象方法...
  • 抽象类和虚基类的定义及用途

    万次阅读 多人点赞 2016-12-21 19:41:51
    抽象类不能实例化对象! 为了让一个类成为抽象类,至少必须有一个纯虚函数。包含至少一个纯虚函数的类视为抽象类! classA { public: virtual void lock(void)=0; virtual void unlock(void)=0; virtual ~A(void); } ...
  • 抽象类、接口、内部类

    千次阅读 2018-12-02 16:09:27
    抽象方法和抽象类必须使用abstract修饰符来定义,有抽象方法的类只能被定义抽象类抽象类里可以没有抽象方法; 规则如下: 抽象类与抽象方法必须使用abstract修饰符来修饰,抽象方法不能有方法体; 抽象类不...
  • 含有abstract修饰符的class 即为抽象类,abstract类不能创建实例对象,含有abstract的方法的类必须定义为abstract class ,abstract class 里的方法不必是抽象的,抽象类定义抽象方法必须放在具体子类中实现,所以...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 385,027
精华内容 154,010
关键字:

抽象类变量定义