抽象类,接口及匿名对象
抽象类
abstract关键字:修饰方法和类
抽象方法:不同类的方法相似,但是具体实现有不尽相同,所以我们只能抽取方法的声明,没有及具体的方法体,没有具体方法体的方法就是抽象方法。
抽象类:有抽象方法的类必须是抽象类。
注意:一个类继承了抽象类需要重写它所有的抽象方法,否则子类就得是抽象类,非抽象方法子类可以不重写。
抽象类的特点:
-抽象方法只能在抽象类里面;
-抽象类和抽象方法必须被abstract修饰;
-抽象类不能创建对象(不能实例化);
-抽象类中可以有非抽象方法,子类可以不必重写非抽象方法;
-抽象类和类的关系也是继承,
-一个类继承了抽象方法,要么重写抽象类的所有抽象方法,要么他自己也是抽象类。
package com.nike.demo01; public class AbstractTest { public static void main(String[] args) { Cat cat = new Cat(); Dog dog = new Dog(); cat.eat(); dog.eat(); } } abstract class Animal { public abstract void eat(); public void run() { } } class Cat extends Animal { @Override public void eat() { System.out.println("猫吃鱼"); } } class Dog extends Animal { @Override public void eat() { System.out.println("狗吃骨头"); } }
final:修饰成员变量,成员方法,类:
-修饰的类不能被继承;
-修饰的成员方法不能被重写;
-修饰的成员变量是常量,不能修改。
常量:
字面值常量:1,2,3
自定义常量:被final所修饰的成员变量,一旦初始化则不可修改。
注意:自定义常量必须初始化,可以显式初始化或者构造初始化。
抽象类的成员特点:
成员变量:可以有成员变量,常量;
成员方法:可以有抽象方法和非抽象方法;
构造方法:可以有构造方法,作用:给成员变量初始化
public class AbstractTest { public static void main(String[] args) { Cat cat = new Cat(); Dog dog = new Dog(); cat.eat(); dog.eat(); dog.barking(); } } abstract class Animal { String name = "旺财"; final int num = 2; public Animal() { } public Animal(String name) { super(); this.name = name; } public abstract void eat(); public void run() { } } class Cat extends Animal { @Override public void eat() { System.out.println("猫吃鱼"); } } class Dog extends Animal { @Override public void eat() { System.out.println("狗吃骨头"); } public void barking(){ System.out.println(name); System.out.println(num); } }
抽象类的细节
抽象关键字abstract不能和哪些关键字共存?
1.final:被final修饰的成员方法不能被重写,final所修饰的类不能被继承。
2.private:父类中被private修饰的方法不能被重写。
抽象类可以没有抽象方法。
接口
Java语言的继承是单一继承,一个子类只能由一个父类。
Java语言给我们提供了一种机制,用于处理继承单一的局限性,接口。
接口,是一个比抽象类还抽象的类,接口里的所有方法都是抽象方法。
接口和类的关系不再是继承,而是实现(implements)。
创建接口的格式:
interface 接口名{}
接口的成员特点:
只能有抽象方法,接口不能创建对象(不能实例化),
一个类实现一个接口,要么实现这个接口的所有方法,要么这个类是抽象类。
接口中默认只能使用public abstract修饰所有方法。
建议手动给上public abstract修饰符。
接口中只能有常量,默认使用public static final 修饰成员属性。
public class InterfaceTest { public static void main(String[] args) { BillGates bg = new BillGates(); bg.code(); bg.manage(); } } class BillGates extends Coder implements Boss { @Override public void manage() { System.out.println("管理公司"); } } interface Boss { int num = 0; public abstract void manage(); } class Coder { public void code() { System.out.println("敲代码"); } }
接口与类之间的关系:
类与类:继承关系,单一继承,多层继承。
类与接口:实现关系,多实现。
接口与接口:继承关系,多层继承,多继承。
接口的优点:
一个类可以实现多个接口,打破了继承的局限性。
接口中所有成员都是公共的,对外提供规则,规范。
降低了程序的耦合性,提高开发的效率,(可以实现模块化开发,定义好规则,每个人实现自己的模块)。
抽象类与接口的区别
共性:
1.不断的抽取,抽取出抽象的概念。
区别:
1.与类之间的关系:类与接口是实现关系,多实现;类与抽象类是继承关系,单一继承,多层继承。
2.成员:
-抽象类可以有成员变量,常量;接口只能有常量。
-抽象类可以有抽象方法,也可以有非抽象方法;接口只能有抽象方法,而且方法有默认修饰符(public abstract)
-抽象类有构造方法;接口没有构造方法
public class InterfaceDemo { public static void main(String[] args) { // TODO Auto-generated method stub BasketballPlayer bp = new BasketballPlayer(); bp.sleep(); bp.learn(); bp.speak(); BasketballCoach bc = new BasketballCoach(); bc.speak(); } } class Person{ String name; int age; String gender; public Person() { } public Person(String name, int age, String gender) { this.name = name; this.age = age; this.gender = gender; } public void eat(){ System.out.println("吃饭"); } public void sleep(){ System.out.println("睡觉"); } } abstract class Player extends Person{ public abstract void learn(); } abstract class Coach extends Person{ public abstract void teach(); } class BasketballPlayer extends Player implements LearnEnglish{ @Override public void learn() { System.out.println("学习扣篮"); } @Override public void speak() { System.out.println("说英语"); } } class PingPongPlayer extends Player{ @Override public void learn() { System.out.println("学习抽球"); } } class BasketballCoach extends Coach implements LearnEnglish{ @Override public void teach() { System.out.println("教扣篮"); } @Override public void speak() { System.out.println("说英语"); } } class PingPongCoach extends Coach{ @Override public void teach() { System.out.println("教抽球"); } } interface LearnEnglish{ public abstract void speak(); }
匿名对象
匿名对象:没有变量引用的变量。
应用场景:当方法只调用一次的时候,可以使用匿名对象。
匿名对象可以调用成员变量,可以赋值,但是没有意义;
可以当作参数传递。