精华内容
下载资源
问答
  • 抽象类和抽象方法的特点
    2020-07-14 14:31:57

    抽象类有以下几个特点:
    1.抽象类不能直接实例化对象但是可以通过子类向上转型得到该类型对象
    2.抽象类也有构造器(所有的类都有构造器)
    3.抽象类可以没有抽象方法,但有抽象方法一定是抽象类
    4.抽象类和普通类使用是一样的,就是多了可以存放抽象方法
    抽象方法:
    1.没有方法体,连{}也没用,直接分号结束;
    2.抽象方法具体实施靠子类重写来实现

    更多相关内容
  •  二、接口:接口是引用类型的,类似于类,和抽象类的相似之处有三点: 1、不能实例化; 2、包含未实现的方法声明; 3、派生类必须实现未实现的方法抽象类是抽象方法,接口则是所有成员(不仅是方法包括其他成员...
  • 而抽象方法就是为了方便继承而引入的,现在来看一下抽象类和抽象方法分别是如何定义以及他们的特点。 什么是抽象方法?我们在类里面定义的只有方法名没有方法体的方法就是抽象方法,所谓没有方法体就是在方法声明的...
  • 本文实例讲述了PHP抽象类和接口用法。分享给大家供大家参考,具体如下: 前言 对于oop,估计大多数人并不陌生。有些人除PHP外也学习不少其他语言,会发现php的不同之处,可能语法极其丑陋,但并不妨碍它成为世界上...
  • 抽象类和抽象方法以及接口 抽象类和抽象方法抽象类:一个设计的非常抽象,以至于它都没有任何具体的实例,这便是抽象类。 ②抽象方法:在方法头前面加abstract关键字修饰 public abstract void getArea{ 类体; }...

    抽象类和抽象方法以及接口

    # 抽象类和抽象方法
    首先抽象的含义就是就是抽取本质特征(共性),加以简单描述。
    ①抽象类:一个设计的非常抽象,以至于它都没有任何具体的实例,这便是抽象类。
    ②抽象方法:在方法头前面加abstract关键字修饰

    public abstract void getArea{
    	类体;
    }
    

    一般形式:访问修饰符 abstract 返回类型 方法名(参数列表)
    抽象方法要求在派生类中重写 抽象方法的类会自动变成抽象类
    实例:重写会出现三角形,如果是抽象的,那三角形是实心的三角形
    重要语法点:
    (1):抽象类可以包含零至多个普通方法,也可以含零至多个普通方法;
    (2):不论抽象类是否含抽象方法,其都不允许实例化
    (3):若父类是抽象类,且子类不能成为抽象类
    什么时候使用抽象方法?
    当多个类有相同的方法,但方法体不一样,这时候就可以抽取出抽象方法
    抽象类和抽象方法的特点:
    1.抽象方法美没有方法体
    2.如果一个类有抽象方法,那这个类必须定义为抽象类
    3.抽象类可以有抽象方法和非抽象方法
    4.抽象类不能继承new对象
    5.继承抽象类,就必须重写抽象类里的所有抽象方法
    抽象类的使用:
    定义父类为抽象类,包含抽象方法
    子类继承父类,实现父类的所有抽象方法
    例子:

    /**
       The StockPurchase class represents a stock purchase.
    */
    
    public class StockPurchase
    {
       private Stock stock;  // The stock that was purchased
       private int shares;   // Number of shares owned
    
       /**
          Constructor
          @param stockObject The stock to purchase.
          @param numShares The number of shares.
       */
    
       public StockPurchase(Stock stockObject, int numShares)
       {
          // Create a copy of the object referenced by
          // stockObject.
    	   stock = new Stock(stockObject);
    	   shares = numShares;
          
       }
       
       /**
          getStock method
          @return A copy of the Stock object for the stock
                  being purchased.
       */
       
       public Stock getStock()
       {
          // Return a copy of the object referenced by stock.
          return new Stock(stock.getSymbol(), stock.getSharePrice());
       }
       
       /**
          getShares method
          @return The number of shares being purchased.
       */
       
       public int getShares()
       {
          return shares;
       }
    
       /**
          getCost method
          @return The cost of the stock purchase.
       */
       
       public double getCost()
       {
          return shares * stock.getSharePrice();
       }
    }
    
    
    

    接口

    1.接口的概念:如果一个类之中只是由抽象方法和全局变量所组成,那么在这种情况下不会将其定义为一个抽象类,而只会将其定义为接口,所以接口严格来说就属于一个特殊的类,而且这个类里面只有抽象方法与全局变量,要定义一个接口使用interface关键字来完成
    举例:

    interface A{//定义了接口
    public static final String zsw="hello";//全局变量
    //抽象方法
    public abstract void print();
    }
    

    接口中所有的方法都是public;接口不能被实例化;接口必须在别处重写。

    接口中的属性:public,final(没法被继承),static;

    如果一个类想要实现接口需要在类头使用:implements关键字

    public class RubberDuck extends Duck implements Quackable
    

    在这里插入图片描述
    接口只能继承接口不能继承类
    由于接口里面存在有抽象方法,所以接口对象不可能直接使用关键字new进行实例化的操作,所以接口的使用原则如下:
    1.接口必须要有子类,但是此时一个子类可以使用implements关键字实现多个接口;
    2.接口的子类(如果不是抽象类),必须要覆写接口中的全部抽象方法;
    3.接口的对象可以利用子类对象的向上转型进行实例化操作

    interface A {// 定义了接口
    	public static final String MSG = "Hello";// 全局常量
    	// 抽象方法
     
    	public abstract void print();
    }
     
    interface B {
    	public abstract void get();
    }
     
    class X implements A, B {// X类实现A和B两个接口
     
    	@Override
    	public void get() {
    		System.out.println("B接口的抽象方法!");
    	}
     
    	@Override
    	public void print() {
    		System.out.println("A接口的抽象方法!");
    	}
    }
     
    public class Demo {
    	public static void main(String args[]) {
    		X x = new X();
    		A a = x;// 向上转型
    		B b = x;// 向上转型
    		a.print();
    		b.get();
    	}
    }
    

    抽象与接口的比较点:
    在这里插入图片描述
    总结:
    1.接口与抽象类定义的不同;
    2.接口作为标准用于解耦合以及不同层之间的连接桥梁;

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

    2022-03-16 15:08:07
    文章目录抽象类与抽象方法抽象类抽象方法例子父类AnimalAnimal的非抽象子类DogAnimal的抽象子类BirdBird的非抽象子类LittleBird测试类测试类运行截图 ​ 类到对象是实例化。对象到类是抽象 抽象类 1、什么是抽象类:...

    抽象类与抽象方法


    ​ 类到对象是实例化。对象到类是抽象

    抽象类

    1、什么是抽象类:
        类和类之间具有的共同特征,但是不完全一样,有着自己的特色,
        将这些共同的特征(方法)提取出来,形成的一个类就是抽象类
        让这些具有共同特征的类去继承它
        注意:这个类是抽象的,也就是"不存在的",所以无法实例化对象(不能new)
        例子:
            比如人类,我们单独创建一个类是无法完全具体的描述完人类的
            比如肤色:有的是白色、有的是黑色、有的是黄色;
            比如瞳孔颜色:有的棕色、有的蓝色、有的黑色...
            显然我们不能说一个人的肤色又是黑色,又是白色;
            一个人的瞳孔色即是棕色又是蓝色...
            这是不合理的,但是这些特色却也有着共同点,比如肤色、瞳孔色,
            虽然我们没法描述完所有肤色,但是我们可以说人类有肤色,
            具体是什么肤色,我们让人类的子类去描述
            比如黄种人、白种人、黑种人...每个子类都有着父类的特征,但也有着自己的特色
            这里的人类就是一个抽象类,我么只是定义了一个模糊的概念,具体的实现细节我们并没有给出
            人类的一个个特征就是一个个抽象方法,具体的实现细节都由继承的子类去描述
    2、抽象类语法格式:
        [修饰符列表] abstract class 类名{
        	类体;
        }
    注意:此处的修饰符列表只能为 public/protected 修饰
    默认为 public 所以没有 default
    不能为 private 否则子类无法继承
    不能用 final 修饰,因为 finalabstract 是互斥的
    	final 修饰的类无法被继承,抽象类不被继承就没有意义
    3、一个抽象类必须要被子类继承!否则这个抽象类是无意义的!
        抽象类的子类可以是抽象类。也可以是非抽象类。
            如果是非抽象类,代表父类的抽象方法必然被全部实现
            如果是抽象类,代表父类的抽象方法'可能没有全部实现',可能子类有自己的抽象方法
        '这里的实现,就是覆盖或者说重写,父类的抽象方法继承后并使其成为非抽象的方法'
    4、抽象类属于什么类型?
    	抽象类也属于引用数据类型。
    5、抽象类既然无法实例化,那么抽象类有构造方法吗?
    	抽象类有构造方法,这个构造方法是供子类使用的
    6、抽象类中能有不抽象的方法吗?
        可以,抽象类中不仅仅只存在抽象方法,也可以存在非抽象的方法
    

    抽象方法

    1、什么是抽象方法呢?
    	抽象方法表示没有实现的方法,没有方法体的方法
    2、抽象类语法格式:
    	[修饰符列表] abstract [返回值类型] 方法名();
    3、抽象方法特点是:
        没有方法体,以分号结尾;
        修饰符列表中有abstract关键字
    4、抽象类中不一定有抽象方法,抽象方法必须出现在抽象类中。
    

    例子

    父类Animal
    package com.blog.abstractTests;
    
    /**
     * @Author jinhuan
     * @Date 2022/3/16
     * 动物类:所有动物的父类
     */
    public abstract  class Animal {
        /**
         * 抽象方法: move()  eat()
         *  具体怎么实现我们没有说明
         * */
        public abstract void move();
    
        public abstract void eat();
    
    }
    
    
    Animal的非抽象子类Dog
    package com.blog.abstractTests;
    
    /**
     * @Author jinhuan
     * @Date 2022/3/16
     * 狗狗类:
     *      一个非抽象类
     *      继承了Animal这个抽象类,则必须实现其所有的抽象方法
     */
    public class Dog extends Animal{
        @Override
        public void move() {
            System.out.println("狗狗摇着尾巴走来啦!");
        }
    
        @Override
        public void eat() {
            System.out.println("狗狗在吃饭,吃的很香!!!");
        }
    }
    
    
    Animal的抽象子类Bird
    package com.blog.abstractTests;
    
    /**
     * @Author jinhuan
     * @Date 2022/3/16
     * Bird类:
     *      一个抽象类
     *          可以选择实现父类中的抽象方法,也可以不实现
     *          如果本类不实现,那么其下级子类如果不是抽象类
     *              则必须实现暂未实现的抽象方法
     *          如果本类实现了父类中的其中一个抽象方法
     *              那么其下级子类不用去实现该已经被实现的抽象方法
     *
     *         可以理解为
     *              在一个家庭中:
     *                   父债子偿,子不能偿,孙子偿...
     *              一旦某一代偿还了,则其后代就不用背负这个债务了
     *
     */
    public abstract class Bird extends Animal{
        /**
         * 只实现了一个抽象方法
         * 那么其非抽象子类必须实现另一个方法
         * */
        @Override
        public void move() {
            System.out.println("很多鸟儿都用翅膀飞!");
        }
    }
    
    
    Bird的非抽象子类LittleBird
    package com.blog.abstractTests;
    
    /**
     * @Author jinhuan
     * @Date 2022/3/16
     */
    public class LittleBird extends Bird {
        @Override
        public void eat() {
            System.out.println("鸟儿在吃饭!叽叽!喳喳!");
        }
    }
    
    
    测试类
    package com.blog.abstractTests;
    
    /**
     * @Author jinhuan
     * @Date 2022/3/16
     *
     * 动物类的测试类
     */
    public class AbTest01 {
        public static void main(String[] args) {
            //Animal animal = new Animal();     不能直接创建抽象类对象
            /**
             * 创建狗狗对象并调用Animal的方法
             * 因为狗狗类已经实现了Animal的所有抽象方法
             * 所以都可以调用
             * */
            Animal dog = new Dog();
            dog.eat();
            dog.move();
            System.out.println("========我是一个分界线===========");
    
            /**
             * 虽然bird类实现了Animal的抽象方法
             * 但是它本质上还是一个用abstract修饰的抽象类
             * 无法实例化
             * */
            //Bird bird = new Bird();
    
            /**
             * 虽然LittleBird类只实现了eat方法
             * 但是其父类已经实现了move方法,子类继承了该方法就可以调用
             * 但是由于LittleBird并没有重写该方法,所以咋调用的时候还是弗雷德实现细节
             * */
            Animal littleBird = new LittleBird();
            littleBird.eat();
            littleBird.move();
        }
    }
    
    
    测试类运行截图

    image-20220316113147848

    调用的时候还是弗雷德实现细节
    * */
    Animal littleBird = new LittleBird();
    littleBird.eat();
    littleBird.move();
    }
    }

    
    ###### 测试类运行截图
    
    [外链图片转存中...(img-DuRuL15k-1647414469296)]
    
    
    展开全文
  • 在Java中,可以通过两种形式来体现OOP的抽象:接口和抽象类。这两者有太多相似的地方,又有太多不同的地方。很多人在初学的时候会以为它们可以随意互换使用,但是实际则不然。我们一起来学习一下Java中的接口和抽象...
  • 主要给大家介绍了关于java中抽象类、抽象方法、接口与实现接口的相关资料,文中通过示例代码将四者介绍的非常详细,并且简单介绍了抽象类和接口的区别,需要的朋友可以参考借鉴,下面随着小编来一起学习学习吧。
  • 大家都知道抽象类无法实例化,就无法创建对象。所以下面这篇文章主要给大家介绍了关于Java实例化一个抽象类对象的相关资料,文中通过示例代码介绍的非常详细,需要的朋友可以参考借鉴,下面随着小编来一起学习学习吧...
  • 抽象类的概述 概述: 使用abstract关键字修饰的类就是抽象类 特点: 这种类不能被创建对象,它就是用来做父类的,被子类继承的 抽象类的定义 格式: 修饰符 abstract class 类名{ } 例如: public abstract class...

    抽象类的概述

    • 概述: 使用abstract关键字修饰的类就是抽象类
    • 特点: 这种类不能被创建对象,它就是用来做父类的,被子类继承的

    抽象类的定义

    • 格式:
    修饰符 abstract class 类名{
        
    }
    
    • 例如:
    public abstract class Person{
    
    }
    

    抽象类中的成员

    • 成员变量
    • 成员方法
    • 构造方法
    • 抽象方法
    abstract class Animal{
        private String name;
    
        public Animal(){
    
        }
    
        public Animal(String name){
            this.name = name;
        }
    }
    
    class Dog extends Animal{}
    
    public class Test {
        public static void main(String[] args) {
            /*
                - 抽象类的概述和特点
                    概述:使用abstract关键字修饰的类就是抽象类
                    特点:抽象类不能创建对象,,它就是用来做父类的,被子类继承的
                - 抽象类的定义
                    修饰符 abstract class 类名{
                    }
    
                - 抽象类中的成员
                    成员变量
                    构造方法
                    set\get方法
                    成员方法
                    抽象方法
                抽象类和普通类的区别:
                    1.抽象类不能创建对象
                    2.抽象类需要使用abstract关键字修饰
                    3.抽象类中可以定义抽象方法
             */
            //Animal anl = new Animal();// 编译报错,因为抽象类不能创建对象
        }
    }
    
    

    小结

    • 使用abstract关键字修饰的类就是抽象类
    • 抽象类中的成员
    • 抽象类的特点

    抽象方法的概述

    • 没有方法体,使用abstract修饰的方法就是抽象方法

    抽象方法的定义

    修饰符 abstract 返回值类型 方法名(形参列表);
    例如:
    	public abstract void work();
    

    抽象方法的作用: 强制要求子类重写的

    abstract class Animal{
        // 抽象方法
        public abstract void eat();
        public abstract void sleep();
    }
    class Dog extends Animal{
        @Override
        public void eat() {
            System.out.println("Dog eat方法...");
        }
    
        @Override
        public void sleep() {
            System.out.println("Dog sleep方法");
        }
    }
    
    abstract class Cat extends Animal{
        @Override
        public void eat() {
            System.out.println("Cat eat方法...");
        }
    }
    
    public class Test {
        public static void main(String[] args) {
            /*
                抽象方法的概述:使用abstract关键字修饰的方法,并且没有方法体
                抽象方法的定义: 修饰符 abstract 返回值类型 方法名(参数列表);
                结论:
                    1.有抽象方法的类一定是抽象类
                    2.抽象类中不一定有抽象方法
                    3.抽象类的子类如果是普通类,那么必须重写父类所有的抽象方法
                    3.抽象类的子类如果是抽象类,那么可以不用重写父类的抽象方法
             */
            Dog d = new Dog();
            d.eat();
        }
    }
    

    小结

    • 抽象方法: 没有方法体,使用abstract修饰的方法就是抽象方法

    抽象类的特点

    • 抽象方法定义格式: 修饰符 abstract 返回值类型 方法名(形参列表);
    • 抽象类不能被创建对象,就是用来做“父类”,被子类继承的。
    • 抽象类不能被创建对象,但可以有“构造方法”——为成员属性初始化。
    • 抽象类中可以没有抽象方法,但抽象方法必须定义在抽象类中
    • 子类继承抽象类后,必须重写抽象类中所有的抽象方法,否则子类必须也是一个抽象类
    abstract class Animal{
        private String name;
        public Animal(){}
        public Animal(String name){
            this.name = name;
        }
        public String getName(){
            return name;
        }
    }
    class Dog extends Animal{
        public Dog(){}
        public Dog(String name){
            // 调用父类的有参构造方法
            super(name);
        }
    }
    
    public class Test {
        public static void main(String[] args) {
            /*
                - 抽象类不能被创建对象,就是用来做“父类”,被子类继承的。
                - 抽象类不能被创建对象,但可以有“构造方法”——为成员属性初始化。
                - 抽象类中可以没有抽象方法,但抽象方法必须定义在抽象类中
                - 子类继承抽象类后,必须重写抽象类中所有的抽象方法,否则子类必须也是一个抽象类
    
             */
            //Animal anl = new Animal();// 编译报错,因为抽象类不能被创建对象
            Dog d = new Dog("旺财");
            System.out.println(d.getName());// 旺财
        }
    }
    

    小结

    • 抽象类不能创建对象,一般用来作为父类,供子类继承
    • 抽象类不能被创建对象,但可以有“构造方法”——为成员属性初始化。
    • 抽象类中可以没有抽象方法,但抽象方法必须定义在抽象类中
    • 子类继承抽象类后,必须重写抽象类中所有的抽象方法,否则子类必须也是一个抽象类
    展开全文
  • 抽象类和普通类的区别: 1.普通类可以创建对象,抽象类不能创建对象 2.普通类没有抽象方法抽象类可以有抽象方法 如图,抽象类Person不能创建对象。 抽象方法 关键字:abstract 概述: 使用 ...
  • (3) 抽象类可以但不是必须有抽象属性抽象方法,但是一旦有了抽象方法,就一定要把这个类声明为抽象类 (4) 具体派生类必须覆盖基类的抽象方法 (5) 抽象派生类可以覆盖基类的抽象方法,也可以不覆盖。如果不覆盖,...
  • Java抽象类和抽象方法

    2021-06-11 10:26:27
    java中可以定义没有方法体的方法称为抽象方法,该方法由子类具体实现,含有抽象方法的类称为抽象类 抽象方法特点 只有方法头没有方法体的方法 抽象方法用abstract修饰 抽象方法代表一种不确定的操作或行为 抽象...
  • 抽象类和抽象方法知识点 抽象类好比一个不具体的汽车蓝图,它不可以直接创造汽车,但是按照它绘制的另一个具体的蓝图可以。 【抽象类的定义】 1.类:用abstract修饰 2.抽象方法:用abstract修饰,且用分号;结束 ...
  • 主要介绍了浅谈Java抽象类和接口的个人理解,具有一定借鉴价值,需要的朋友可以参考下。
  • 7.何为抽象方法和抽象类方法前有个abstract修饰符,就叫抽象方法。类前有个abstract修饰符就是抽象类,完了,简单就好记。 以下是二者的要点: 1)抽象方法没有函数体。有童鞋说,这有什么意义呢?比如下面的...
  • Java中的抽象类和接口

    千次阅读 多人点赞 2022-04-08 15:17:42
    各位铁汁们大家好呀!今天让我们继续学习java,看看java中的抽象类和接口到底是什么? 里面也会讲到多态呀,一起来看看吧
  • 一、使用abstract修饰符修饰的类被称为抽象类; 抽象类不能实例化对象,只能... 抽象方法不能有方法体,子类必须重写抽象类中所有的抽象方法;三、抽象类中不一定包含抽象方法,但包含抽象方法的类一定是抽象类;...
  • 抽象方法 ...抽象类特点 (1)抽象类不能实例化,既不能创建对象 (2)子类直接继承抽象类会报错;解决方法:要么子类也是一个抽象类,要么重写父类的所有抽象方法 (3)抽象类有构造器,这个构造..
  • 抽象类+抽象方法

    千次阅读 2021-01-09 15:56:30
    对于这样的场景,我们可以将动物类,设计为抽象类抽象类不能被实例化对象,只是提供了所有的子类的共有的部分,为了给所有的子类定义公共属性 abstract class Animal{ String name; int age; public void eat(){} ...
  • 抽象类和抽象方法.pdf

    2019-08-06 09:21:33
    抽象类和抽象方法.pdf
  • 抽象类与抽象方法

    2022-04-09 20:14:27
    类的设计应该保证父类子类能够共享特征。有时将一个父 类设计得非常抽象,以至于它没有具体的实例,这样的类叫做抽象类 二、如何使用 1)用abstract关键字来修饰一个类,这个类叫做抽象类。 2)用abstract来修饰一...
  • 主要介绍了java抽象类和接口定义与用法,结合实例形式详细分析了java抽象类和接口的基本概念、原理、定义、使用方法及操作注意事项,需要的朋友可以参考下
  • Java 抽象类与oop三大特征 面向对象主要有三大特性:继承多态.封装. 一.抽象类 在了解抽象类之前,先来了解一下抽象方法.抽象方法是一种特殊的方法:它只有声明,而没有具体的实现.抽象方法的声明格式为: abstract ...
  • 可以修饰方法:叫做抽象方法,没有方法体,需要使用分号表示声明结束,抽象方法所在的类必须是抽象类 子类必须重写父类的抽象方法,除非子类也是抽象类 使用abstract关键字修饰,只表示声明了一个方法,但是没有任何...
  • 类的继承结构中,越往上...定义抽象类的作用是将一类对象的共同特点抽象出来,成为代表该类共同特性的抽象概念,其后在描述某一具体对象时,只要添加与其他子类对象的不同之处,而不需要重复类的共同特性。这样就使...
  • 抽象类和接口

    千次阅读 2020-11-24 19:38:35
    那么父类的方法声明和方法体,只有声明还有意义,而方法体内容则没有存在的意义。我们把这种没有方法体内容的方法称为抽象方法。Java语言规定,如果一个类包含了抽象的方法。那么该类就是一个抽象类 定义: ​ ...
  • 类都设计应该保证父类子类能够共享特征。有时将一个父类设计得非常抽象,以至于它没有具体都实例,这样都类叫做抽象类。 2.abstract修饰类:抽象类 1⃣️抽象类不能实例化。 public static void main(String[] ...
  • 抽象类和抽象方法本身特点 抽象类无法实例化对象,但它的子类可以 抽象方法没有方法体,抽象方法本身没有任何意义,除非被重写 抽象类和抽象方法关系 抽象类可以没有抽象方法 但声明了抽象方法的类一定要...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 432,162
精华内容 172,864
关键字:

抽象类和抽象方法的特点