精华内容
下载资源
问答
  • 抽象类抽象方法能不能被重写
    2021-11-05 22:43:45

    方法重写:

    • 子类出现了和父类中一样的方法声明,方法名和参数列表一样;
    • 方法重写可以沿袭父类的功能,又能定义子类特有的内容
    • Override注解可以用来检测当前的方法,是否是重写的方法。

    方法重写注意事项:

    • 私有方法不能被重写,私有成员不能被外界访问,所以不能继承;
    • 子类重写方法访问权限不能降低(public > 默认 > 私有),必需大于等于父类
    • 静态方法不能被重写,如果子类也有相同的方法,不属于方法重写。

    fianl关键字 :

    • final代表最终的意思,可以修饰方法,变量和类。
      • 修饰类:该类不能被继承
      • 修饰方法:该方法不能重写不希望子类重写的方法,可以用fianl修饰;
      • 修饰基本数据类型的变量:表明该变量是一个常量,不能再次赋值
      • 修饰引用数据类型的变量:地址值不可改变,地址内的数据可以改变

    抽象类:

    • 有些方法在父类中不能具体明确,需要子类单独进行重写,这个时候就需要抽象类了;
    • 抽象方法是没有方法体的方法,一个类中如果有抽象方法,该类必须定义为抽象类。

    抽象类的特点:

    • 抽象类和抽象方法必须使用 abstract 关键字修饰

      //抽象类的定义
      public abstract class 类名 {}
      ​
      //抽象方法的定义
      public abstract void eat();
    • 抽象类中不一定有抽象方法,但有抽象方法的类一定是抽象类;

    • 抽象类可以有构造方法,但不能创建对象

    • 抽象类的子类,要么重写抽象类中的所有抽象方法,要么是抽象类,抽象方法终将重写

     

    更多相关内容
  • 不能重写只适用于实例方法,不能用于静态方法,而子类当中含有和父类相同签名的静态方法,我们一般称之为隐藏.

    不能,重写只适用于实例方法,不能用于静态方法,而子类当中含有和父类相同签名的静态方法,我们一般称之为隐藏.
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 1.继承:父类和子类之间是层级结构关系,子类通过继承父类拥有父类的非private的属性和方法。...或者用于修饰方法,该方法不能被子类重写。 6)子类是不继承父类的构造器(构造方法或者构造函数)的,它只是调用(隐式或

    1.继承:父类和子类之间是层级结构关系,子类通过继承父类拥有父类的非private的属性和方法。提高了代码的复用性。
    1)单继承:只能允许继承自一个父类;
    2)子类可以扩展,即拥有自己的属性和方法;
    3)子类可以重写父类的方法;
    4)super关键字来实现对父类成员的访问,用来引用当前对象的父类。this关键字:指向自己的引用。
    5)final 关键字声明类可以把类定义为不能继承的,即最终类;或者用于修饰方法,该方法不能被子类重写。
    6)子类是不继承父类的构造器(构造方法或者构造函数)的,它只是调用(隐式或显式)。

    2.方法的重写与重载
    1)重写:子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。
    2)重载:在一个类里面,方法名字相同,而参数不同。返回类型可以相同也可以不同。

    3.抽象类和抽象方法
    1)抽象类:不能实例化对象,必须有子类继承才能使用。抽象类并不一定含抽象方法。
    2)抽象方法:拥有抽象方法的类,一定是抽象类。抽象方法只包含一个方法名,而没有方法体。子类必须重写实现该抽象方法。

    4.接口:是抽象方法的集合,接口通常以interface来声明。
    1)类描述对象的属性和方法。接口则包含类要实现的“抽象”方法。
    2)接口无法被实例化,但是可以被实现。一个实现接口的类,必须实现接口内所描述的所有方法,否则就必须声明为抽象类。
    3)接口可以支持多继承。
    4)接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract(只能是 public abstract,其他修饰符都会报错)。
    5)接口中可以含有变量,但是接口中的变量会被隐式的指定为 public static final 变量(并且只能是 public,用 private 修饰会报编译错误)。
    6)一个类可以实现多个接口

    普通类的继承的定义与使用:

    package com.example.javatest;
    /**
     * Author:W
     * 动物基类继承
     */
    public class Animal {
        protected   String name;
    
        public  Animal()
        {
    
        }
    
        public Animal(String name)
        {
            this.name = name;
        }
    
        //子类方法重写:吃
        public void  eat(){}
        //子类方法重写:跑
        public  void  run(){}
    }
    
    
    
    
    package com.example.javatest;
    
    /**
     * Author:W
     * 狗
     */
    public  class  Dog extends Animal
    {
        /*==============方法重载==========*/
        public Dog()
        {
    
        }
    
        public Dog(String name)
        {
            super(name);
        }
    
        /*==============方法重写==========*/
        @Override
        public void eat() {
    //       super.eat();
            System.out.println("狗:"+name+" 在吃...");
        }
    
        @Override
        public void run() {
    //        super.run();
            System.out.println("狗:"+name+" 在跑...");
        }
    }
    

    抽象类的继承定义与使用:

    package com.example.javatest;
    
    /**
     * Author:W
     * 形状(抽象类继承)
     *
     */
    public abstract class Shape {
        public  float width;
        public  float height;
        //抽象方法:没有方法体
        public  abstract  float GetArea(float width,float height);
    }
    
    package com.example.javatest;
    
    /**
     * Author:W
     * 三角形
     */
    public class Triangle extends Shape{
    
        @Override
        public float GetArea(float width, float height) {
            this.width = width;
            this.height = height;
    
            float area = width*height/2;
            System.out.println("三角形的面积:"+area);
            return area;
        }
    }
    
    package com.example.javatest;
    
    /**
     * Author:W
     * 正方形
     */
    public class Rectrangle extends Shape{
    
        @Override
        public float GetArea(float width,float height) {
            this.width = width;
            this.height = height;
    
            float area = width * height;
            System.out.println("正方形的面积:"+area);
            return area;
        }
    }
    

    接口的定义与使用

    package com.example.javatest;
    
    /**
     * Author:W
     * USB接口1
     */
    public interface USB {
        public int X = 3;//相当于public static final int X = 3;
        public void adjust();//相当于public abstract void adjust();
        public void power();
    }
    
    package com.example.javatest;
    
    /**
     * Author:W
     * USB接口2
     */
    public interface USB2 {
        public void rechagre();
    }
    
    package com.example.javatest;
    
    /**
     * Author:W
     * 接口实现
     */
    public class  MusicUSB implements USB,USB2
    {
        @Override
        public void adjust()
        {
             System.out.println("MusicUSB实现接口USB方法adjust");
        }
    
        @Override
        public void power()
        {
            System.out.println("MusicUSB实现接口USB方法power");
        }
    
        @Override
        public void rechagre() {
            System.out.println("MusicUSB实现接口USB2方法rechagre");
        }
    }

    测试脚本类

    package com.example.javatest;//包名定义
    
    /**
     * Author:W
     * 1.继承:父类和子类之间是层级结构关系,子类通过继承父类拥有父类的非private的属性和方法。提高了代码的复用性。
     * 1)单继承:只能允许继承自一个父类;
     * 2)子类可以扩展,即拥有自己的属性和方法;
     * 3)子类可以重写父类的方法;
     * 4)super关键字来实现对父类成员的访问,用来引用当前对象的父类。this关键字:指向自己的引用。
     * 5)final 关键字声明类可以把类定义为不能继承的,即最终类;或者用于修饰方法,该方法不能被子类重写。
     * 6)子类是不继承父类的构造器(构造方法或者构造函数)的,它只是调用(隐式或显式)。
     *
     * 2.方法的重写与重载:
     * 1)重写:子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。
     * 2)重载:在一个类里面,方法名字相同,而参数不同。返回类型可以相同也可以不同。
     *
     * 3.抽象类和抽象方法:
     * 1)抽象类:不能实例化对象,必须有子类继承才能使用。抽象类并不一定含抽象方法。
     * 2)抽象方法:拥有抽象方法的类,一定是抽象类。抽象方法只包含一个方法名,而没有方法体。
     *
     * 4.接口:是抽象方法的集合,接口通常以interface来声明。
     * 1)类描述对象的属性和方法。接口则包含类要实现的“抽象”方法。
     * 2)接口无法被实例化,但是可以被实现。一个实现接口的类,必须实现接口内所描述的所有方法,否则就必须声明为抽象类。
     * 3)接口可以支持多继承。
     * 4)接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract(只能是 public abstract,其他修饰符都会报错)。
     * 5)接口中可以含有变量,但是接口中的变量会被隐式的指定为 public static final 变量(并且只能是 public,用 private 修饰会报编译错误)。
     * 6)一个类可以实现多个接口
     */
    public class MainTest {
        public static void main(String[] args)
        {
             System.out.println("=====普通类的继承====");
             Animal dog = new Dog("阿黄");
             dog.eat();
    
             System.out.println("=====抽象类的继承====");
             Shape  triangle = new Triangle();
             triangle.GetArea(3.5f,5f);
    
             System.out.println("=====接口的实现====");
             USB  musicUSB1 = new MusicUSB();
             musicUSB1.adjust();
             musicUSB1.power();
    
             USB2 musicUSB2 = new MusicUSB();
             musicUSB2.rechagre();
    
        }
    }
    

    运行结果如下:

    展开全文
  • NUMPAGES java方法重载重写抽象类抽象方法接口多态 方法的重载是指一个类中可以定义有相同的名字但参数不同的多个方法调用时会根据不同的参数选择对应的方法 方法重写是指与被重写方法具有相同方法名称参数列表和...
  • Java中抽象类方法重写

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

    1. 抽象类

    	关键字:abstract
    

    :用来描述一类具体的事物
    抽象类:抽象的、模糊的、不具体的类

    在Java的普通类中是不允许多继承的,原因是会出现调用
    不明确的问题;
    

    总结:父类中的功能是不能删除的,但其形式是不需要的(没有存在的意义),此时就可以将父类中功能的 具体实现 形式 给删掉;
    类的具体实现:创建对象

    抽象方法存在的意义是什么?

    	用于定义功能,明确该类具备此功能-----规则
    

    特点:

    	1.抽象类可以有抽象方法,也可以有非抽象的方法
    
    	2.抽象类中可以有构造器,但是不能创建对象,
    	  空间需要由子类对象来开辟
    

    2. 方法的重写

    方法重载:在同一个类中,方法名相同,参数列表不同(参数位置、参数个数、参数类型),与返回值无关

    方法重写:在继承或实现的关系下,方法名相同,参数列表相同,返回值类型相同,子类的修饰权限要大于或等于父类中的修饰符权限

    1. 什么情况下需要重写父类中的类型呢

    1.1 子类有自己的特殊实现形式时,此时就可以重写父类中的功能
    	如果没有特殊实现就不需要重写(此时重写不是必须的)
    
    2.1 所有的子类都有自己的特殊实现形式时,父类中的功能也就没
        必要有具体的实现,就会变成抽象,那此时,其所有的子类都
        必须重写父类中全部的抽象方法
    
    1. @Override 称为注解,此处的含义是重写,如果方法上加上了该注解,就代表该方法是从父类中重写过来的(如果此时删除了父类中的该方法,子类就会报错)
    // 调用
    public class Demo {
    	public static void main(String[] args) {
    		
    	}
    }
    
    package day0202;
    // 爷爷类(抽象类)
    public abstract class Old {
    	private String type;
    	private String name;
    	private String color;
    	private int age;
    	
    	public abstract void eat();
    	public abstract void sleep();
    	public abstract void weight();
    	
    	
    	
    	public void ear() {
    		System.out.println("圆圆的");
    	}
    	public void tail() {
    		System.out.println("尾部是卷的");
    	}
    	
    	
    	public String getType() {
    		return type;
    	}
    	public void setType(String type) {
    		this.type = type;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public String getColor() {
    		return color;
    	}
    	public void setColor(String color) {
    		this.color = color;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	
    	
    }
    
    
    package ****;
    // 父类继承爷爷类
    	public class Parent1 extends Old {
    		
    		private String eyes;
    		
    		
    		@Override
    		public void eat() {
    			super.ear();
    			super.tail();
    			System.out.println("吃肉,通过哺乳其他动物");
    		}
    		
    		@Override
    		public void sleep() {
    			System.out.println("困了就睡觉");
    		}
    		
    		@Override
    		public void weight() {
    			System.out.println("比较大");
    		}
    	}
    
    

    当在继承关系中,子父类中有相同的方法或变量时,程序的编译执行有什么区别

    	非静态的方法:执行的时候走的是子类中覆盖后的方法
    	非静态的变量:执行的时候走的是子类中的变量
    
    • 静态的方法:执行的是调用者中的方法

    • 静态的属性:执行的是调用者中的方法

    • 抽象方法不能与哪些关键字共存?

    private:private修饰的方法只能在本类中使用,而抽象方法要求必须让子类实现,两者相互矛盾
    final:final修饰的方法不能被重写,而抽象方法必须要被重写,
    static:static修饰的方法可以通过类名直接调用,而抽象方法是没有方法体的

    展开全文
  • 抽象类的定义及方法重写

    千次阅读 2020-11-10 21:04:22
    抽象类的定义及方法重写 抽象类的关键词:abstract 首先定义一个抽象类(Phone) public abstract class Phone{//定义一个抽象类 //思考:1>应用场景 2>如何定义 //抽象类可以看作是一个具体的类...
  • 方法重写基础知识,多态的好处与弊端,向上转型和向下转型,多态内存的基础知识,抽象类的基础知识概述
  • C#方法重写抽象类,抽象方法

    千次阅读 2019-10-11 23:39:18
    方法重写 顾名思义,方法重写就是要重写一些发法,不过不是手改代码,而是诸如...可被重写方法有如下三类 虚方法:virtual 抽象方法:abstract 重写方法:override 抽象类 抽象类的概念:是由abstract修饰...
  • 当继承抽象类时,抽象类方法必须全部重写吗? 二、解答问题 编写抽象类Animal.java,该抽象类下有两个抽象方法,一个eat(),另一个是run() 2.编写普通类Cat.java 当我们只重写了父类中一个抽象方法时,IDE提示了...
  • 接口和抽象类中只有方法名,没有定义的,如果你不定义 也就是空方法,接口就是为了弥补java不能多重继承,接口针对的是对象而不是实现。实现的部分可以交由对象去实现。这就是java中的多态啊。 ...
  • 主要介绍了Java抽象类和抽象方法定义与用法,结合实例形式详细分析了Java抽象类和抽象方法相关原理、定义、使用方法及操作注意事项,需要的朋友可以参考下
  • C# 抽象类与抽象方法

    2021-12-29 04:49:56
    01—前言 如果一个类与具体的事物相联系,而只是表达一种抽象的概念,仅仅是作为其派生类的一个基类,这样的类就是抽象类。在抽象类中声明方法时,如果加上abstract关键字,则为抽象方法...
  • PHP中的抽象类和抽象方法自己用的不多,但是经常会在项目中看到别人使用,同样,今天在看别人的代码的时候,发现使用了抽象类,就总结下: 抽象类: 1、如果一个类中有一个方法是... 3、抽象类不能实例化对象  4、如
  • 主要给大家介绍了关于java中抽象类、抽象方法、接口与实现接口的相关资料,文中通过示例代码将四者介绍的非常详细,并且简单介绍了抽象类和接口的区别,需要的朋友可以参考借鉴,下面随着小编来一起学习学习吧。
  • 抽象类实现接口时可以重写接口里部分的方法或者不重写接口中的方法
  • java方法重载、重写抽象类、抽象...重写方法不能使用比被重写方法更严格的访问权限。抽象类、抽象方法:用abstract关键字来修饰一个类时,这个类叫抽象类;abstract修饰一个方法时,该方法叫做抽象方法。含有抽...
  • public class ExtendsTest { // 访问修饰对重载无影响,即使访问修饰符不同,但它们也构成重载 public void test1(){ System.out.println("修饰符对重载的影响"); ...(重写override) 发生在
  • 1.抽象类:有抽象方法的类必定是抽象类抽象类一定要继承,而且抽象方法一定要被重写,所以凡是继承了抽象方法一定要重写,但是普通方法并不要求必须重写方法。 abstract不能和private final st...
  • 0.复习: 0.1 静态: ​ 1.静态成员变量:作为数据 所有对象共享 属于的 ​ 2.静态成员方法:工具 ​ 3.静态代码块: 初始化数据 0.2 工具: ​ 1.Arrays: ​
  • 一.方法重写 在继承的情况下,子类的方法满足以下条件,称为方法重写 1.方法名相同 2.参数列表相同 3.返回值类型相同或者是父类返回值的子类 ...构造方法不能被重写 方法重写方法重载的区别于联系 二.多态 ...
  • 2.如果父类中某个方法想要继承的子类都重写方法,那么该方法不能存在方法抽象方法:没有方法体的方法就是抽象方法抽象方法必须使用abstract关键字修饰 语法: 修饰符 abstract 返回值类型 方...
  • 1. 子类是抽象类 如果你的新类也是抽象类的话,可以重写部分,也可以不重写; 2. 子类是普通类 如果是普通类,就必须要全部重写
  • 可使用虚方法重写方法抽象方法来定义类型层次结构的行为。 由于可从基类派生,因此这些派生可能需要修改在基类中实现的行为。 虚方法是在基类中声明和实现的方法,其中任何派生都可提供更具体的实现。...
  • 原 static修饰的方法不能被重写可以继承以及抽象类不能有静态的抽象方法 2018年07月11日 10:40:29 爆发的~小宇宙 阅读数:793 &...
  • 多个中存在相同属性和行为时,将这些内容抽取到单独一个中,那么多个中无需再定义这些属性 和行为,只需要和抽取出来的构成某种关系。如图所示: 其中,多个可以称为子类,也叫派生;多个抽取出来的...
  • 对应这一现象,Java中提供了抽象类,它只能作为父类,不能实例化。定义抽象类的作用是将一类对象的共同特点抽象出来,成为代表该类共同特性的抽象概念,其后在描述某一具体对象时,只要添加与其他子类对象的不同之处...
  • 重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变,核心重写!父亲只是有那个想法,但是具体实现是子类去实现。 2.抽象类abstract,没有大括号,里面没有内容,...
  • 抽象类不能被实例化,可以有构造器、初始代码块、内部类,main方法;一个类若包含了抽象方法,则一定是抽象类;但抽象类不一定含有抽象方法;抽象方法只能声明不能有函数体,且必须是public(默认)或protected,否则...
  • 抽象类重写

    2020-11-11 11:50:47
    父类中很多功能是不需要的、重复的,但是功能是不能删除的,它的实现形式是不需要的,此时就可以将父类中功能的具体方法删掉,变为抽象方法方法,类就变为抽象类。 关键字:abstract 3.抽象方法存在的意义是什么? ...
  • Java --- 接口、抽象类方法重写

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 307,011
精华内容 122,804
关键字:

抽象类抽象方法能不能被重写