精华内容
下载资源
问答
  • 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);
    	}
    
    }
    
    

    运行结果:

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

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

    展开全文
  • 注入的,我有一个Email的抽象类 ``` public abstract class Mail { protected boolean isEmailContentValid = true; } ``` 然后有多个子类机型了这个Email抽象类,比如AEmail extends Mail ``` public ...
  • 新手小白学JAVA 抽象类

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

    抽象类

    1 概念

    Java中可以定义被abstract关键字修饰的方法,这种方法只有声明,没有方法体,叫做抽象方法.
    Java中可以定义被abstract关键字修饰的类,被abstract关键字修饰的类叫做抽象类

    1. 如果一个类含有抽象方法,那么它一定是抽象类
    2. 抽象类中的方法实现交给子类来完成

    2 抽象方法的格式

    在这里插入图片描述

    3 特点

    1. abstract 可以修饰方法或者类
    2. 被abstarct修饰的类叫做抽象类,被abstract修饰的方法叫做抽象方法
    3. 抽象类中可以没有抽象方法
    4. 如果类中有抽象方法,那么该类必须定义为一个抽象类
    5. 子类继承了抽象类以后,要么还是一个抽象类,要么就把父类的所有抽象方法都重写
    6. 多用于多态中
    7. 抽象类不可以被实例化

    4 练习:抽象类入门案例

    创建包: cn.tedu.oop
    创建类: AbstractDemo.java

    package cn.tedu.oop;
    /*本类用作抽象测试的入门案例*/
    public class AbstractDemo {
        public static void main(String[] args) {
            /*4.抽象类不可以实例化!!!-创建对象*/
            //5.测试抽象父类是否可以创建对象
            //Animal a = new Animal();
            //6.创建多态对象进行测试
            Animal a = new Pig();
            a.eat();//调用抽象父类的普通方法
            a.fly();//调用抽象父类的抽象方法
    
        }
    }
    //1.创建父类Animal
    /*2.被abstract修饰的类是抽象类
    * 如果一个类中包含了抽象方法,那这个类必须被声明成一个抽象类*/
    //4.2添加抽象方法后,本类需要用abstract修饰
    abstract class Animal{
        //3.创建普通方法
        public void eat(){
            System.out.println("吃啥都行~");
        }
        public void play(){
            System.out.println("玩啥都行~");
        }
        //4.1创建抽象方法
        /*1.被abstract修饰的方法是抽象方法,抽象方法没有方法体*/
        public abstract void fly();
        public abstract void fly2();
    }
    //2.创建子类Pig,并与Animal类建立继承关系
    /*3.当一个子类继承了抽象父类以后,有两种解决方案:
    * 方案一:变成抽象子类,“躺平,我也不实现,继续抽象”
    * 方案二:实现抽象父类中的所有的抽象方法,“父债子偿”*/
    //4.3子类需要处理,继续抽象/实现父类所有抽象方法
    //abstract class Pig extends Animal{--方案一
    class Pig extends Animal{//方案二
        @Override//注解,标识这是一个重写的方法
        public void fly() {
            System.out.println("我爸的债我终于还清了,我家的猪终于飞起来了~");
        }
    
        @Override
        public void fly2() {
            System.out.println("抽象父类中的所有抽象方法都需要被实现");
        }
    }
    
    
    
    

    5 练习:抽象类构造函数测试

    抽象类中的构造函数通常在子类对象实例化时使用

    创建包: cn.tedu.oop
    创建类: AbstractDemo2.java

    package cn.tedu.oop;
    /*本类用作抽象类构造函数测试*/
    /*抽象类是否有构造方法?有
    * 既然抽象类不能实例化,为什么要有构造方法呢?
    * 不是为了自己使用,而是为了子类创建对象时使用super(); */
    public class AbstractDemo2 {
        public static void main(String[] args) {
            //4.测试抽象类是否可以创建对象?不可以!!!
            //Animal2 a = new Animal2();
            //5.创建子类对象进行测试
            Pig2 p = new Pig2();
        }
    }
    //1.创建抽象父类Animal2
    abstract class Animal2{
        //3.创建构造方法
        public Animal2(){
            System.out.println("我是Animal2的构造方法~");
        }
    }
    //2.创建子类Pig2
    class Pig2 extends Animal2{
        //6.创建子类的无参构造
        public Pig2(){
            super();//表示调用父类的无参构造
            System.out.println("我是Pig2的构造方法~");
        }
    }
    

    6 练习:抽象类成员测试

    创建包: cn.tedu.oop
    创建类: AbstractDemo3.java

    package cn.tedu.oop;
    /*本类用作抽象类中的成员测试*/
    public class AbstractDemo3 {
    }
    //1.创建抽象父类Fruit
    abstract class Fruit{
        /*1.抽象类中可以定义成员变量吗?--可以!!!*/
        //3.1定义抽象父类中的成员变量
        int sum = 100;
        /*2.抽象类中可以定义成员常量吗?--可以!!!*/
        //3.2定义抽象父类中的成员常量
        final String name = "XIAOHUANGREN";
        /*3.抽象类中可以定义普通方法吗?--可以!!!
        * 抽象类中可以都是普通方法吗?--也可以!!!*/
        /*4.如果一类中都是普通方法,那它为啥还要被修饰成抽象类呢?
        * 因为抽象类不可以被实例化,所以如果不想让外界创建本类的对象
        * 就可以把普通类声明成抽象类*/
        //4.定义抽象父类的普通方法
        public void clean(){
            System.out.println("水果还是要洗洗再吃哒~");
        }
        /*5.抽象类中可以定义抽象方法吗?--可以!!!*/
        /*6.如果类中添加了抽象方法,那么这个类必须被声明成抽象类*/
        //5.定义抽象父类中的抽象方法
        public abstract void grow();
        public abstract void clean2();
    }
    //2.创建子类Banana
    /*如果一个子类继承了抽象父类,有两种处理方案:
    * 方案一:继续抽象,也就是作为抽象子类,无需实现抽象方法-"躺平"
    * 方案二:不再抽象,实现继承自父类中的所有未实现的抽象方法-"父债子偿"*/
    class Banana extends Fruit{
        @Override
        public void grow() {
            System.out.println("一串香蕉老沉了~");
        }
        @Override
        public void clean2() {
            System.out.println("香蕉不用洗,香蕉喜欢被扒皮");
        }
    }
    

    拓展

    总结:abstract注意事项

    抽象方法要求子类继承后必须重写。
    那么,abstract关键字不可以和哪些关键字一起使用呢?以下关键字,在抽象类中。用是可以用的,只是没有意义了。
    1.private:被私有化后,子类无法重写,与abstract相违背。
    2.static:静态优先于对象存在,存在加载顺序问题。
    3.final:被final修饰后,无法重写,与abstract相违背。

    程序设计: 分析老师示例—面向抽象编程

    具体事物: 培优班老师 高手班老师
    共性: 讲课 备课

    创建包: cn.tedu.design
    创建类:DesignTeacher.java

    package cn.tedu.design;
    /**本类用于设计老师类,面向抽象编程*/
    public class DesignTeacher {
    	public static void main(String[] args) {
    		CGBTeacher ct = new CGBTeacher();
    		SCDTeacher st = new SCDTeacher();
    		ct.ready();
    		ct.teach();
    		st.ready();
    		st.teach();
    	}
    
    }
    //生活中的事物--类
    //特征--属性  &  行为--方法
    
    //属性:姓名 工号
    //方法:备课 讲课
    abstract class Teacher{
    	int id ;//工号
    	String name;//姓名
    	//备课方法
    	public abstract void ready();
    	//讲课方法
    	public abstract void teach();
    }
    
    /**培优班CGB老师--主打电商项目*/
    class CGBTeacher extends Teacher{
    	@Override
    	public void ready() {
    		System.out.println("正在备课...电商项目....");
    	}
    	@Override
    	public void teach() {
    		System.out.println("正在授课...电商项目....");
    	}
    }
    /**SCD大数据老师--主打Scala语言*/
    class SCDTeacher extends Teacher{
    	@Override
    	public void ready() {
    		System.out.println("正在备课...hadoop");
    	}
    	@Override
    	public void teach() {
    		System.out.println("正在讲课...spark");
    	}
    }
    
    展开全文
  • java抽象类

    万次阅读 多人点赞 2019-05-13 21:39:28
    下面小编给大家讲一个java抽象类,在面向对象的概念,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类...

    开发工具与关键技术:MyEclipse 10、java语言、
    作者:邓李庆
    撰写时间: 2019年5月10日
    下面小编给大家讲一个java的抽象类,在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类;抽象来除了不能实例化对象之外,类的其它功能依然存在,成员变量、成员方法、初始化块和构造方法和普通类一样。由于抽象类不能实例化对象,所以抽象类必须被继承,才能被使用。
    抽象方法:只包含一个方法名,而没有方法体,使用abstract修饰
    格式: {修饰符} abstract 返回类型 方法名();
    修饰符(pubic protected private)三选一,见代码图1:
    在这里插入图片描述
    图1
    抽象类必须使用abstract修饰符来修饰。抽象方法也必须使用abstract修饰符来修饰,不能有方法体。
    抽象类不能被实例化,无法使用new关键字来调用抽象类的构造器创建抽象类的实例;
    抽象类可以包含成员变量、方法(普通方法和抽象方法都可以)、构造器、初始化块、内部类(接口、枚举)5种成分。抽象类的构造器不能用于创建实例,主要是用于被其子类调用。抽象类中不一定包含抽象方法,但是有抽象方法的类必定是抽象类。Abstract static不能同时修饰一个方法
    接口(interface),在java编程语言中是一个抽象类型,是抽象方法的集合,接口通常以interface来声明。一个类通过继承接口的方式,从而来继承接口的抽象方法。接口并不是类,编写接口的方式和类很相似,但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。除非实现接口的类是抽象类,否则该类要定义接口中的所有方法。接口无法被实例化,但是可以被实现。一个实现接口的类,必须实现接口内所描述的所有方法,否则就必须声明为抽象类。
    在java中,接口类型可用来声明一个变量,他们可以成为一个空指针,或是被绑定在一个以此接口实现的对象;修饰符public、abstract;接口的特性:
    1)接口是隐式抽象的,当声明一个接口的时候,不必使用abstract关键字。
    2)接口中每一个方法也是隐式抽象的,声明时同样不需要abstract关键字。
    3)接口中的方法都是公有的。
    4)编译时自动为接口里定义的方法添加public abstract修饰符
    5)java接口里的成员变量只能是public static final共同修饰的,并且必须赋初值,可以不写public static final,编译的时候会自动添加。
    见代码图2:
    在这里插入图片描述
    图2
    当类实现接口的时候,类要实现接口中所有的方法。否则,类必须声明为抽象的类。类使用implements关键字实现接口。在类声明中,implements关键字放在class声明后面。
    在这里插入图片描述
    图3
    一个接口能继承另一个接口,和类之间的继承方式比较相似。接口的继承使用extends关键字,子接口继承父接口的方法。接口允许多继承;抽象类和接口差异:

    抽象类接口
    默认的方法实现它可以有默认的方法实现接口完全是抽象的。它根本不存在方法的实现
    实现子类使用extends关键字来继承抽象类。如果子类不是抽象类的话,它需要提供抽象类中所有声明的抽象方法的实现类使用关键字impements来实现接口。它需要提供接口中所有声明的方法的实现
    构造器抽象类可以有构造器接口不能有构造器
    与正常java类的区别除了不能实例化抽象类之外,它和普通java类没有任何区别接口是完全不同的类型
    访问修饰符抽象方法可以有pubic、protected和default这些修饰符接口方法默认修饰符是public。你不可以使用其它修饰符
    main方法抽象方法可以有main方法并且我们可以运行它接口没有main方法,因此我们不能运行它
    多继承抽象类可以继承一个类和实现多个接口接口只可以继承一个或多个其它接口
    添加新方法如果你往抽象类中添加新的方法,你可以给它提供默认的实现,因此你不需要改变你现在的代码如果你往接口中添加方法,那么你必须改变实现接口的类
    展开全文
  • java抽象类详解

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

    1、Java抽象类存在的意义,为什么要使用抽象类?
    利于代码的维护和复用。把相同的方法或者属性抽象出来放在一个抽象类中,让类去继承,则实现了复用。
    2、什么是抽象类?
    加上abstract关键字的类即为抽象类。
    3、抽象类可以实例化吗?也就是说可以new吗?
    抽象类是不可以进行new的。所以想要使用抽象类,必须要用类来继承它,然后可以用子类对象进行实例化。(抽象类自身不能创建对象,但是它的子类可以创建对象。)
    4、抽象类中可以有什么?需要注意什么?
    抽象类中可以定义属性和方法,
    5、抽象类中可以不定义抽象方法吗?不定义会怎么样?
    (1)抽象类中可以定义普通方法,定义普通方法要有方法体,子类中可以重写也可以不重写。如果不重写,调用的则是父类的方法。
    (2)抽象类中也可以定义抽象方法,定义抽象方法不能有方法体(因为是抽象出来的方法,所以不能有方法体,方法体是子类去重写即体现出多态),且子类中必须实现。
    注:抽象方法只能存在抽象类中
    6、当实现一个接口不想重写所有的方法应该怎么做?
    抽象类来实现接口,则不必重写接口的方法。可以全部不重写或只重写一部分方法。然后由抽象类的子类来重写。

    展开全文
  • Java 抽象类

    千次阅读 2021-06-12 17:59:19
    如果父类只知道子类应该包含怎样的方法,却无法准确的知道子类如何实现这些方法,那么我们需要设计抽象类
  • Java抽象类

    千次阅读 多人点赞 2018-06-04 15:49:24
    这句话概括了抽象的概念,而在Java中,你可以只给出方法的定义不去实现方法的具体事物,由子类去根据具体需求来具体实现。这种只给出方法定义而不具体实现的方法被称为抽象方法,抽象方法是没有方法体的,在代码的...
  • java 抽象类

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

    千次阅读 2018-12-04 21:45:27
    Java语言使用abstract class来定义抽象类 抽象类除了不能实例化对象之外,类的其它功能依然存在,成员变量、成员方法和构造方法的访问方式和普通类一样。 由于抽象类不能实例化对象,但可以定义一个引用。抽象...
  • 主要介绍了Java抽象类用法与注意点,结合实例形式详细分析了java抽象类的定义、使用及相关操作注意事项,需要的朋友可以参考下
  • java中抽象类和接口的特点

    千次阅读 2016-08-02 15:19:34
    5. 抽象类中可以存在普通属性、方法、静态属性和静态方法 6. 抽象类中的抽象方法需要有子类实现,如果子类不实现,则子类也需要定义为抽象的 java中接口的特点: 1. 接口的方法,永远都被
  • Java 抽象类与接口 编程练习

    千次阅读 2020-04-16 12:47:19
    (1)使用接口或者抽象类实现基类Employer(体会接口和抽象类的不同),包含姓名、部门和工资三个属性,显示工资的方法showSalary()和显示奖金的抽象方法showBonus();提示:因每位职工奖金不同,showBonus()...
  • java抽象类和接口有什么意义

    千次阅读 2021-02-04 16:53:06
    为什么接口和抽象类不能实例化,为什么接口可以多个实现而抽象类只能单继承,特别是java8之后,抽象类和接口里面都可以写代码后,就更加分不清了,今天重新整理一下。 什么是抽象类(abstract class) 使用abstract...
  • 一、抽象类与普通类 二、抽象类与接口 三、小结 概念 抽象类和具体类是相对的概念。“抽象”是一种存在思想逻辑的概念,而“具体”是一种可见可触摸的现实对象。简单说,比如“人”比“男人”抽象一点,...
  • Java定义抽象类

    千次阅读 2019-09-16 19:17:07
    Java语言,可以通过把类或者类的某些方法声明为abstract(abstract只能用来修饰类或者方法,不能用来修饰属性)来表示一个类是抽象类抽象类不能被实例化 举例 定义一个抽象类,作为父类,定义两个抽象方法,后期...
  • Java抽象类用法示例详解

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

    千次阅读 2017-12-20 09:18:19
    抽象类抽象类是无法实例化的特殊类。所以问题是为什么我们需要一个不能被实例化的类,抽象类只能是子类(继承自)。换句话说,它只允许其他类继承它,但不能实例化。优点是它为所有子类执行特定的层次结构。简而言之...
  • Java 抽象类 接口 继承 实现

    千次阅读 2016-07-23 17:21:14
    接口和抽象类的概念不一样。接口是对动作的抽象,抽象类是对根源的抽象。 抽象类表示的是,这个对象是什么。接口表示的是,这个对象能做什么。比如,男人,女人,这两个类(如果是类的话……),他们的抽象类是人。...
  • java-抽象类和继承抽象类

    万次阅读 2018-02-09 16:17:15
    抽象类和继承抽象类 抽象类不能直接实例化,需要创建一个指向自己的对象引用(其子类)来实例化 代码: public class Main { public static void main(String[] args) { /* People people = new People(); *...
  • Java中抽象类和接口的区别

    万次阅读 多人点赞 2019-02-07 14:10:07
    Java中,可以通过两种形式来体现OOP的抽象:接口和抽象类。这两者有太多相似的地方,又有太多不同的地方。很多人在初学的时候会以为它们可以随意互换使用,但是实际则不然。今天我们就一起来学习一下Java中的接口...
  • 抽象类与接口的异同点分别体现...3.接口只能定义静态常量,不能定义普通变量或非静态的常量,而抽象类中则可以定义不同的属性,也可以定义静态的属性。 4.接口不包含构造器,而抽象类中可以包含构造器,抽象类中
  • JAVA抽象类的定义

    万次阅读 多人点赞 2018-08-25 19:24:40
    抽象类的基本概念 抽象方法,只声明而未实现的方法我们称为抽象方法,所有的抽象方法都需要用abstract关键字声明,包含抽象方法的类也需要使用abstract关键字声明,抽象类和普通类相比,区别在于抽象类带有抽象...
  • spring对抽象类中属性的自动注入

    万次阅读 2013-05-06 11:21:04
    在使用spring的时候,有时由于设计的需要,需要使用抽象类(比如模板方法模式),但在抽象类中实现方法是需要依赖其他的接口或类的方法,这时就需要对依赖的接口或类进行注入,需要注意以下内容: 在抽象类中需要...
  • java中抽象类与接口的区别

    千次阅读 2017-10-14 15:08:27
    java中抽象类与接口的区别一、抽象类用abstract关键字修饰一个类时,这个类叫做抽象类,用abstract修饰一个方法时,这个方法叫做抽象方法。含有抽象方法的类必须被声明为抽象类抽象类必须被继承,抽象方法必须被...
  • java抽象类有构造方法吗?

    千次阅读 2020-05-27 21:50:09
    抽象类中的 方法 抽象方法 abstract void eat(); 没有方法体,没有{},以; 结尾. 非抽象方法 void sleep(){ syso .... } 抽象类子类: 1.非抽象类,但是必须重写父类的抽象方法 2.抽象类,无须管抽象...
  • Java中抽象类与方法的重写

    千次阅读 2020-11-10 22:29:33
    1. 抽象类 关键字:abstract 类:用来描述一类具体的事物 抽象类:抽象的、模糊的、不具体的类 在Java的普通类是不允许多继承的,原因是会出现调用 不明确的问题;...抽象类中可以有构造器,但是不能创建
  • Java中接口和抽象类的区别

    千次阅读 2019-04-29 19:51:53
    java中接口和抽象类的区别 ...
  • java抽象类使用注意事项

    千次阅读 2021-04-23 13:53:30
    抽象类的使用条件:当父类的某些方法,需要声明,但是有不确定如果实现时,可以将其声明为抽象方法那么这个类也就要声明为抽象类,那么这个类就时抽象类 当父类的一些方法不能确定时,可以用abstract关键字来修饰该...
  • Java中抽象类与接口,一篇就够啦

    千次阅读 多人点赞 2020-04-19 16:44:36
    文章目录Java中抽象类与接口Java中抽象类Java中接口 Java中抽象类与接口 Java中抽象类 抽象类的定义 定义:类的修饰符 abstract class 类名 抽象类跟普通的类定义相比,就是在原来的基础上,加上一个abstract...
  • 解决Java抽象类无法注入

    千次阅读 2020-08-13 18:58:18
    原因:spring的原理是启动服务器时读取配置文件,取得类名后利用反射机制在spring上下文中生成一个单例的对象,由spring注入属性并维护此对象的状态,抽象类在反射生成对象时就已经失败了,后面的不会进行 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 308,531
精华内容 123,412
关键字:

java抽象类中的属性

java 订阅