java的抽象类
文章内容选自尚硅谷,jdk8,eclipse环境
abstract关键字的用法
abstract关键字可以用来修饰类和方法。
abstract关键字修饰类
abstract修饰的类表明该类不可实例化,要想调用类中的方法,就让该类被子类继承,通过子类来调用父类的方法。
代码演示
package com.atguigu.java;
public class AbstractTest {
public static void main(String[] args) {
// Person p1 = new Person();
}
}
abstract class Person{
String name;
int age;
public Person(){
}
public Person(String name,int age){
this.name = name;
this.age = age;
}
public void eat(){
System.out.println("人吃饭");
}
public void walk(){
System.out.println("人走路");
}
}
class Student extends Person{
}
注释的部分是编译不通过的部分,因为把Person声明为抽象类,则不可进行实例化。
抽象类中也是有构造器的,它的构造器用于子类的调用。也可以用于创建匿名子类。
abstract关键字修饰方法
- abstract关键字修饰的方法叫做抽象方法。抽象方法没有方法体,不能够被调用。
- 因为抽象方法不能被调用,所以要声明抽象方法所属类也为抽象类。抽象类不一定非得有抽象方法,有抽象方法的类一定是抽象类。
- 抽象方法也会被子类所继承,若想实例化子类对象,就要让子类重写父类所有的抽象方法,这儿的父类包含直接父类和间接父类。否则编译器会报错。
- 子类若不重写父类的抽象方法,则必须把子类也声明为抽象类,否则编译器报错。
演示代码如下
abstract class Person{
String name;
int age;
public Person(){
}
public Person(String name,int age){
this.name = name;
this.age = age;
}
//不是抽象方法,只要有大括号,就算有方法体
// public void eat(){
//
// }
//是抽象方法,因为没有方法体
public abstract void eat();
public void walk(){
System.out.println("人走路");
}
}
抽象方法是没有方法体的,表现形式为没有大括号。
抽象方法只在父类中起一个声明的作用,告诉实例化子类必须重写抽象方法才能使用,子类要重写直接父类和间接父类的所有抽象方法。
public class AbstractTest {
public static void main(String[] args) {
// Person p1 = new Person();
}
}
abstract class creature{
public abstract void breath();
}
abstract class Person extends creature {
String name;
int age;
public Person(){
}
public Person(String name,int age){
this.name = name;
this.age = age;
}
//不是抽象方法,只要有大括号,就算有方法体
// public void eat(){
//
// }
//是抽象方法,因为没有方法体
public abstract void eat();
public void walk(){
System.out.println("人走路");
}
}
class Student extends Person{
public Student(String name,int age){
super(name,age);
}
public void eat(){
System.out.println("学生吃饭");
}
@Override
public void breath() {
System.out.println("学生呼吸");
}
}
abstract在使用上的注意点
abstract关键字与其他几个关键字的使用有冲突。表现为
- abstract不能用来修饰私有方法,因为私有方法不能被重写。
- abstract不能用来修饰静态方法,子类和父类中若存在同名同参数的方法,如果方法都是非static的,则构成重写,如果都声明为static的,他们不是重写,这是因为静态方法不能被覆盖。如果只有一个是static,编译器报错。
- abstract不能用来修饰final的方法和带final的类。因为final类不能被继承,final方法不能被重写。
abstract练习
图片选自尚硅谷PPT
首先得编写一个Employee得父类,声明为抽象类。
package com.atguigu.exer1;
public abstract class Employee {
private int id;
private String name;
private double salary;
public Employee() {
super();
}
public Employee(int id, String name, double salary) {
super();
this.id = id;
this.name = name;
this.salary = salary;
}
public abstract void work();
}
创建构造器时直接alt+shift+s来创建。
再创建一个Manager类,创建子类的时候,在eclipse的弹框中选择继承的父类Employee,可以直接得到重写的work方法。
package com.atguigu.exer1;
public class Manager extends Employee {
private double bonus;
public Manager(double bonus) {
super();
this.bonus = bonus;
}
public Manager(int id, String name, double salary, double bonus) {
super(id, name, salary);
this.bonus = bonus;
}
@Override
public void work() {
System.out.println("管理");
}
}
创建一个CommonEmployee类
package com.atguigu.exer1;
public class CommonEmployee extends Employee {
@Override
public void work() {
System.out.println("工作");
}
public CommonEmployee(int id, String name, double salary) {
super(id, name, salary);
}
public CommonEmployee() {
super();
// TODO Auto-generated constructor stub
}
}
再测试
package com.atguigu.exer1;
public class EmployeeTest {
public static void main(String[] args) {
Employee manager = new Manager(1001,"库克",100,1000);
manager.work();
CommonEmployee commonemployee = new CommonEmployee();
commonemployee.work();
}
}
结果为
管理
工作
此为一个抽象类的简单运用。
创建抽象类的匿名子类对象
匿名对象的使用
首先看匿名对象的使用,在之前AbstractTest的包内建立一个PersonTest类
package com.atguigu.java;
public class PersonTest {
public static void main(String[] args) {
method(new Student());
}
public static void method(Student s){
}
}
以上表现为一个匿名对象的使用。但是类并非匿名的。
非匿名类的非匿名的对象
此为正常写法。
package com.atguigu.java;
public class PersonTest {
public static void main(String[] args) {
method(new Student());
Worker worker = new Worker();
method1(worker);//非匿名的非匿名的对象
}
public static void method(Student s){
}
public static void method1(Person p){
p.eat();
p.breath();
}
}
class Worker extends Person{
@Override
public void eat() {
// TODO Auto-generated method stub
}
@Override
public void breath() {
// TODO Auto-generated method stub
}
}
如果写成
method1(new Worker());//非匿名类的匿名对象
即为非匿名类的匿名对象,对象名不知道,但是对象所属的类知道。
匿名子类
在main方法中创建一个匿名类
public static void main(String[] args) {
method(new Student());
Worker worker = new Worker();
method1(worker);//非匿名类的非匿名的对象
method1(new Worker());//非匿名类的匿名对象
//匿名类的非匿名对象
Person p1 = new Person(){
@Override
public void eat() {
System.out.println("eat");
}
@Override
public void breath() {
System.out.println("breath");
}
};
}
这儿创建了一个匿名类的对象,对象为p1,但类名未知,故称之为匿名类。Person p1 = new Person(){重写的方法}; 这儿大括号内部重写父类的抽象方法,且重写方法的内容是任意的,故为一个新的子类,又没有类名,成为匿名类。这儿也可以看作是一个多态的使用。
在main方法中允许
method1(p1);
结果为
eat
breath
匿名子类的匿名对象
还可以用匿名类的匿名对象
method1(new Person(){
@Override
public void eat() {
System.out.println("eat eat");
}
@Override
public void breath() {
System.out.println("breath breath");
}
});
结果为
eat eat
breath breath
注意区分与之前 匿名类的非匿名对象的分号 有一个分号的差别。