-
2021-04-24 01:49:24
结论:
1) 实例化子类时必须先实例化父类;
2) 抽象类中的方法调用子类实现的抽象方法
3) 抽象类可以在子类未实例化时调用子类实现的抽象方法;
4) 在抽象类的构造方法中调用了自己未实现的抽象方法,那么对应子类实现了此方法;在抽象类实例化之后,子类未实例化之前,抽象类可以调用子类实现的抽象方法。
代码如下:
package com.example;
public class Test {
public static void main(String[] args) {
new Child();
//结果:初始化父类---->child eat---->child jump---->初始化子类
}
}package com.example;
/**
* Created on 2017/5/5.
* Author:crs
* Description:XXX
*/
public class Child extends Parent {
public Child() {
System.out.println("实例化子类");
}
@Override
void eat() {
System.out.println("child eat");
}
@Override
void jump() {
System.out.println("child jump");
}
}
package com.example;
/**
* Created on 2017/5/5.
* Author:crs
* Description:XXX
*/
public class Child extends Parent {
public Child() {
System.out.println("实例化子类");
}
@Override
void eat() {
System.out.println("child eat");
}
@Override
void jump() {
System.out.println("child jump");
}
}
更多相关内容 -
9.2 抽象类定义、子类是抽象类
2020-08-12 09:24:09想了解更多请查看java学习(idea版) 目录 抽象类定义 列:抽象类练习 列:当子类是抽象类时 列:发红包案例 ...抽象类定义 ... Java语法规定,包含抽象方法的类一定是抽象类,在class之前...(当子类是抽象类时,抽象.想了解更多请查看java学习(idea版)
目录
抽象类定义
- 没有方法主体的方法称为抽象方法
- Java语法规定,包含抽象方法的类一定是抽象类,在class之前写上abstract即可
如何使用抽象类和抽象方法:
- 1. 不能直接创建new抽象类对象。必须用一个子类来继承抽象父类
- 2. 抽象类中可以有抽象方法和成员方法、构造方法,抽象方法没有方法体
- 3. 子类必须覆盖重写抽象父类当中所有的抽象方法。(当子类是抽象类时,抽象的父类可以选择性覆盖重写抽象方法)
- 4 . 抽象类的子类,必须重写抽象父类中所有的抽象方法,否则,编译无法通过而报错。除非该子类也是抽象类。
一个抽象类不一定含有抽象方法,只要保证抽象方法所在的类是抽象类即可。
列:抽象类练习
列:当子类是抽象类时
public abstract class Animal { public abstract void eat(); }
public abstract class Dog extends Animal { @Override public void eat() { System.out.println("狗都喜欢吃屎"); } }
public class MyDog extends Dog { @Override public void eat() { super.eat(); System.out.println("我的狗不喜欢吃屎"); } }
列:发红包案例
抽象父类User
public class User { private String name; // 姓名 private int money; // 余额,也就是当前用户拥有的钱数 public User() { } public User(String name, int money) { this.name = name; this.money = money; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getMoney() { return money; } public void setMoney(int money) { this.money = money; } @Override public String toString() { return "User{" + "name='" + name + '\'' + ", money=" + money + '}'; } }
群组类继承User类 ,群主发红包
public class Manager extends User{ public Manager() { } public Manager(String name, int money) { super(name, money); } //创建一个集合存储红包金额,红包数量 public ArrayList<Integer> send(int totalMoney,int count){ ArrayList<Integer> list=new ArrayList<>(); int leftMoney=super.getMoney();//获取群组当前金额 if (totalMoney>leftMoney){ System.out.println("余额不足,发不了红包"); return list; } super.setMoney(leftMoney-totalMoney);//群组发红包后剩余金额 int avg=totalMoney/count;//每份金额钱数 int mod=totalMoney%count;//均分后余额 for (int i = 0; i < count-1; i++) { list.add(avg); } list.add(avg+mod);//最后一份红包金额 return list; } }
群成员类继承User类,成员类接受红包
public class Member extends User { public Member() { } public Member(String name, int money) { super(name, money); } public void receive(ArrayList<Integer> list){ //随机获取红包 int index = new Random().nextInt(list.size());//随机生成红包的编号 int delta=list.remove(index);//收到的红包金额 int money=super.getMoney();//用户原有金额 super.setMoney(money+delta);//用户新金额 } }
测试
public static void main(String[] args) { Manager manager=new Manager("群主",100);//创建群主 Member a=new Member("用户a",20);//创建用户a Member b=new Member("用户b",20);//创建用户b Member c=new Member("用户c",20);//创建用户c //群主发20元钱红包,分成3个 ArrayList<Integer> list=manager.send(20,3); a.receive(list); b.receive(list); c.receive(list); System.out.println(manager.toString()); System.out.println(a.toString()); System.out.println(b.toString()); System.out.println(c.toString()); }
结果
-
JAVA——抽象类
2021-03-09 00:47:50一、抽象类的概念包含一个抽象方法的类就是抽象类,其本质是对多个普通类中相同的部分的抽象。二、抽象类的特点1.抽象方法和抽象类使用 abstract 修饰;...6.抽象类的抽象方法强制子类重写;7. 抽象类中所有的内容...一、抽象类的概念
包含一个抽象方法的类就是抽象类,其本质是对多个普通类中相同的部分的抽象。
二、抽象类的特点
1.抽象方法和抽象类使用 abstract 修饰;
2.有一个抽象方法的类必须是抽象类;
3.抽象类中一定有抽象方法,反之不成立;
4.抽象类不能够实例化 ,即不能创建对象;
5.抽象类的成员一般使用 public 或者 protected修饰;
6.抽象类的抽象方法强制子类重写;
7. 抽象类中所有的内容均是用来给子类使用;
三、抽象类与普通类的区别
抽象类和普通类在结构上的区别:抽象类有抽象方法,而普通类没有。
四、抽象类的子类的特点
1 如果子类想要继承抽象类,就必须实现抽象类中所有的抽象方法;
2 如果子类不想实现父类的抽象方法,那么子类必须升级为抽象类。
五、代码演示
例:编写一个交通工具类,具有前进run()功能,其子类有自行车、小轿车、地铁,重写父类方法。
主人有属性name,age属性,方法回家goHome(交通工具),需要使用交通工具,使用抽象类优化程序。
public static void main(String[] args) {
Hoster hoster = new Hoster("张三", 30);
Vehicle v = new Bike(); //使用多态创建对象
hoster.goHome(v); //调用goHome()方法
//创建匿名对象new Car(),并将其作为goHome()方法的形式参数
hoster.goHome(new Car());
//创建匿名对象new Hoster("李四", 31)并赋值,再调用goHome()方法
new Hoster("李四", 31).goHome(new Subway());
}
class Hoster {
private String name;
private int age;
public Hoster() {
super();
}
public Hoster(String name, int age) {
super();
this.age = age;
}
public void goHome(Vehicle v) {
v.run(this); //将参数传递给此处goHome方法,再调用this所指向对象 // (谁调用的goHome就指向谁)的run()方法。
}
public String getName() {
return name;
}
public void setName(String name) {
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
abstract class Vehicle { //abstract修饰的抽象类
public abstract void run(); //abstract修饰的抽象方法
public abstract void run(Hoster hoster); //abstract修饰的抽象方法
}
class Bike extends Vehicle {
@Override //run()方法重写
public void run() {//实现父类中的抽象方法
System.out.println("自行车在跑");
}
@Override//run(Hoster hoster)方法重写
public void run(Hoster hoster) {//实现父类中的抽象方法
System.out.println(hoster.getName() + "骑着自行车回家"); //执行
}
}
class Car extends Vehicle {
@Override//run()方法重写
public void run() {//实现父类中的抽象方法
System.out.println("小轿车在跑");
}
@Override//run(Hoster hoster)方法重写
public void run(Hoster hoster) {//实现父类中的抽象方法
System.out.println(hoster.getName() + "开着小轿车回家");//执行
}
}
class Subway extends Vehicle {
@Override //run()方法重写
public void run() {//实现父类中的抽象方法
System.out.println("地铁在跑");
}
@Override // run(Hoster hoster)方法重写
public void run(Hoster hoster) {//实现父类中的抽象方法
System.out.println(hoster.getName() + "坐着地铁回家");//执行
}
}
-
Java 抽象类——父类及子类特点与使用
2020-09-28 17:39:23Java抽象类 详解 一、抽象类的基本概念 普通类是一个完善的功能类,可以直接产生实例化对象,并且在普通类中可以包含有构造方法、普通方法、static方法、常量和变量等内容。而抽象类是指在普通类的结构里面...Java抽象类 详解
一、抽象类的基本概念
普通类是一个完善的功能类,可以直接产生实例化对象,并且在普通类中可以包含有构造方法、普通方法、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); } }
运行结果:
机器人充电 机器人工作 人吃饭 人睡觉 人工作 猪进食 猪睡觉
所有的子类如果要想正常的完成操作,必须按照指定的方法进行覆写才可以,而这个时候抽象类所起的功能就是一个类定义模板的功能。
-
继承了抽象类的子类需要把抽象类中的方法重写一遍吗?
2018-10-31 21:39:05继承了抽象类的子类需要把抽象类中的方法重写一遍吗? 抽象类中的非抽象方法不用重写,其他必须重写,接口的方法必须重写; 接口和抽象类中只有方法名,没有定义的,如果你不定义 也就是空方法,接口就是为了弥补... -
java中抽象类的作用是什么?抽象类作用的例子
2021-03-01 08:02:24你知道java当中抽象类的作用是什么吗?有什么作用?下面和小编一起来详细的了解一下具体的作用,以及看看抽象类作用的例子吧!一、java抽象类的作用java抽象类的作用具体的可以分成以下的三点:1、抽象类通常都是用来... -
子类调用抽象父类.zip
2021-08-25 11:39:33子类调用抽象父类,并强制子类重写父类的抽象属性,然后调用父类的方法输出 -
java-抽象类 子类实现相同方法 想想去执行抽象类中的方法,在从抽象类中调用子类具体方法
2015-11-27 02:29:02如下代码,想得到这样结果execute AA before execute..C execute AA after 应该怎么处理 public class Test { public static void main(String[] args) { C c = new C(); c.A(); } } interface YY { ... -
java中抽象类的子类可以定义为抽象类吗
2017-02-18 15:55:43java中抽象类的子类可以定义为抽象类吗?比如我可以在在抽象子类中再扩展抽象方法 -
抽象类通过子类被实例化
2019-12-03 13:50:00抽象类其实是可以被实例化的,但是它的实例化方式并不是通过普通的new方式来创建对象,而是通过父类的应用来指向子类的实例间接地实现父类的实例化,因为子类在实例化之前,一定会先实例化它的父类。这样创建了继承... -
抽象类和普通类的区别是什么?java类和抽象类的区别
2021-02-27 14:38:55你知道java当中的普通类和抽象类之间有什么区别吗?这两者的不同之处究竟是什么呢?下面就和小编一起来详细的了解一下吧。...2、除了以上的一点之外,抽象类它能够有构造函数,被继承的时候,子类就一... -
什么是抽象类?怎么定义?
2021-09-01 09:47:26什么是抽象类?怎么定义?这是属于java技术里面的一个知识点,本期教程就是围绕这个问题做的相关介绍,当定义一个类时,常常需要定义一些成员方法描述类的行为特征,但有时这些方法的实现方式是无法确定的。例如,在... -
如何写抽象类的匿名子类
2021-05-11 20:26:50抽象类的匿名子类的写法: 在创建匿名子类对象的时候重写抽象类中的方法 抽象类 package java; public class AbstractTest { public static void main(String[] args) { Student stu = new Student();//... -
子类继承(extends)抽象类(Abstract)类,注意问题
2020-04-23 23:41:01父类为抽象类,子类继承父类时,父类有的成员变量,方法,子类都有,但是,子类要重写父类里面的抽象方法。 //父类 public abstract class AbstractLogger { public static int INFO = 1; public static int DEBUG... -
JAVA之抽象类与接口的区别
2020-12-22 17:26:15它可以有构造器,但是不能构造对象,抽象类中的构造器,在构造具体子类对象时调用,抽象方法决定抽象类,抽象类中可以没有抽象方法,具体父类型可以作为引用类型的声明;抽象父类型也可以作为引用类型的声明;... -
PHP abstract 抽象类定义与用法示例
2020-12-20 00:56:072.在子类实现抽象类的方法时,其子类的可见性必须大于或等于抽象方法的定义 3.抽象类的方法可以有参数,也可以为空 4.如果抽象方法有参数,那么子类的实现也必须有相同的参数个数 示例: //作用:抽象类不实现... -
Java中抽象类的概述及其详解(什么是抽象类?为什么要使用抽象类?抽象类的特点?)
2019-05-09 17:19:59回想前面我们的猫狗案例,...而是一个抽象的事物。只有真正的猫,狗才是具体的动物。同理,我们也可以推想,不同的动物吃的东西应该是不一样的,所以,我们不应该在动物类中给出具体体现,而是给出一个声明即可。 ... -
【Java】一个子类同时继承抽象类和实现接口
2020-08-09 21:27:37先继承抽象类在实现接口 class C extends B implements A interface A{ public abstract void say(); } abstract class B{ public abstract void fun(); } class C extends B implements A{ public void say() ... -
通过具体程序来理解PHP里面的抽象类
2021-01-21 15:44:34当然,可能存在多个根类,用来实现不同的功能.... 你也可以把抽象类看成是子类的一个模板. 如果你覆写所有的抽象方法, 子类就变成一个普通的类. 如果没有覆写所有方法, 子类仍是抽象的. 如果一个类中中包含有抽象方法(哪 -
抽象类Shape及其子类
2020-03-19 14:19:21定义抽象类Shape,圆形Circle、长方形Square、Rectangle为子类。 Shape类有一个数据成员(double型),定义带参构造方法、抽象方法calArea()(返回值类型:double)在Circle、Square两个类中,实现calArea()方法。在... -
什么是抽象类,什么情况下会用到抽象类?
2021-11-16 17:12:43①抽象类定义: 在面向对象的概念中,世间...抽象类有一个特征,其抽象方法,必须在子类重写(子类非抽象类),所以,当我们父类的方法,必须要子类重写实现时,而且子类又想继承父类的其他方法时,用抽象类。 ... -
Java中的抽象类和接口
2022-04-08 15:17:42各位铁汁们大家好呀!今天让我们继续学习java,看看java中的抽象类和接口到底是什么? 里面也会讲到多态呀,一起来看看吧 -
java抽象类 继承
2021-03-08 06:02:32关于java抽象类 继承的搜索结果回答抽象类和接口的区别:默认的方法实现抽象类可以有默认的方法实现完全是抽象的。接口根本不存在方法的实现。抽象类中可以有已经实现了的方法,也可以有被abstract修饰的方法(抽象... -
在抽象类内调用自身抽象方法会调用子类的实现方法
2020-09-01 19:11:30设置一个抽象父类,一个继承的子类 public abstract class Parent { protected abstract void log(); protected void use(){ log(); } @Test public void test(){ use(); } } public class Children ... -
带你了解什么是抽象类,抽象类不能够被实例化为什么还有构造方法?
2020-06-03 09:52:19接口是我们常用的,抽象类好像并不是怎么常用,但这并不代表他不重要,他可以被继承,可以有构造方法,可以给类中的成员变量赋初值,接口就没有这样的功能。 抽象类的出现使得... -
3.抽象类:什么是抽象类???抽象类的特点有哪些???
2020-06-16 16:33:091.什么是抽象类? 被abstract修饰的类,称为抽象类 定义方式: public abstract class 类名{ } 抽象类不能被实例化,即不能使用new创建一个对象,只能被继承 被abstract修饰的方法,称为抽象方法 定义方式: public ... -
什么是抽象类 抽象类有什么好处 为什么要用抽象类
2019-10-24 20:55:31抽象类: 被abstract修饰的类 * 抽象方法: 被abstract修饰的方法 * 可以没有方法体 * 必须在抽象类中 * * 注意: * 1.抽象类不能被实例化|不能创建对象 * 2.抽象方法要存在与抽象类中,抽象方法必须被重写 * 3.抽象类... -
不允许使用抽象类类型的对象怎么办_什么是抽象类?
2020-11-20 08:46:26抽象类概述分析事物时, 发现了共性的内容,就出现向上抽取,但是如果父类 的方法功能与子类不同,那么这时就不抽取方法主体,这样抽取出来的方法 就是抽象方法 什么是抽象类有抽象方法的类 抽象类和普通的父类有什么区别...