1、抽象类:
当父类的一些方法不能确定时,即不知道方法体里面写什么时,可以让abstract关键字类修饰该方法,这个方法就是抽象方法,当一个类中存才抽象方法时,需要将该类声明为抽象类。
abstract class Animal{
String name;
int age;
abstract public void cry(); // 抽象方法没有方法体。
}
一般来说,抽象类会被继承,由其子类来实现抽象方法。
抽象类的价值更多在于设计,是设计者设计好后,让子类继承并实现抽象类。在框架和设计模式使用较多。
1.1 抽象类细节:
1、抽象类不能被实例化:不能new。
2、抽象类不一定里面要有抽象方法,但是类里面有抽象方法,则这个类必须声明为abstract。
3、abstract只能修饰类和方法,不能修饰属性和其它。
4、抽象类里面可以有任意成员(抽象类本质还是类)。
5、如果一个类继承了抽象类,则它必须实现抽象类的所有抽象方法,除非他自己也声明为抽象类。
6、抽象方法不能使用private、final、static来修饰,因为他们和重写相违背。
抽象类最佳实现形式:模板设计:
public static void main(String[] args) {
AA aa = new AA();
aa.calculateTime(); // 3ms
BB bb = new BB();
bb.calculateTime(); // 2ms
}
abstract public class Template{ // 模板
public abstract void job();// 抽象方法
public void calculateTime() {
long start = System.currentTimeMills(); // 获取当前时间,返回毫秒
job(); // 动态绑定机制。哪个对象调用就指向哪个对象的job方法
long end = System.currentTimeMills();
System.out.println("任务执行时间为:" + (end - start));
}
}
public class AA extends Template{
public void job() { // 重写模板job方法。
long num = 0;
for(long i = 1; i < 600000; i++) {
num += i;
}
}
}
public class BB extends Template{
public void job() { // 重写模板job方法。
long num = 0;
for(long i = 1; i < 6000; i++) {
num *= i;
}
}
}
2、接口:
2.1、接口入门:
// 1、写一个USB接口
public interface UsbInerface {
// 规定接口的相关方法
public void start(); // 接口抽象方法可以不写abstract
public void stop();
}
// 2、写一个phone类,实现 usb接口:实现就是重写接口方法
public class Phone implements UsbInerface {
@Override
public void start() {
System.out.println("手机开始工作");
}
@Override
public void stop() {
System.out.println("手机停止工作");
}
}
// 3、再写一个camera类,实现 usb接口:实现就是重写接口方法
public class Camera implements UsbInerface {
@Override
public void start() {
System.out.println("相机开始工作");
}
@Override
public void stop() {
System.out.println("相机停止工作");
}
}
// 4、写一个computer类,接入接口
// 使用这个电脑接口来调用方法
public class Computer {
public void work(UsbInterface usbInterface) { // 将接口传入
usbInterface.start(); // 通过接口调用方法
usbInterface.stop();
}
}
public static void main(String[] args) {
// 1、创建手机、相机对象
Camera camera = new Camera();
Phone phone = new Phone();
// 2、创建电脑对象
Computer computer = new Computer();
computer.work(camera); // 将相机接入到电脑
computer.work(phone);
}
2.2、接口介绍:
1、是什么:接口就是给出一些没有实现的方法,封装到一起,某个类需要使用时,再根据具体情况把这些方法写出来。
2、语法:
interface 接口名 {
// 1、可以写属性
public int n1 = 10;
// 2、可以写抽象方法方法:接口中,抽象方法可以省略abstract关键字
public void hi();
// 3、jdk8及以后,可以写默认实现方法,要用default关键字修饰
default public void ok() {
System.out.println("ok");
}
// 4、jdk8及以后,可以写静态方法。
public static void cry() {
System.out.println("cry");
}
}
3、类如何使用接口:implements关键字
class Cat implements iAnterface {
// 写自己属性、自己方法
// 必须实现接口的所有抽象方法
}
2.3、接口使用细节:
1、接口不可以被实例化。
2、接口中的所有方法都是public方法,接口中的抽象方法可以不用abstract修饰。
interface AA {
void sayHi(); // 可以不用public也不用写abstract
}
3、一个普通类实现接口,就必须将接口的所有方法都实现;可以使用alter+enter快捷键
4、抽象类实现接口,可以不用实现接口方法。
5、一个类可以同时实现多个接口。
interface IB {
void hi();
}
interface IC {
void say();
}
class Pig implements IB,IC {
@Overfide
public void hi() {}
@Overfide
public void say() {}
}
6、接口中的属性,只能是final的,而且是public static final 修饰符
int a = 1; // 实际是:public static final int a = 1; 只是默认省略了
7、接口中的属性访问形式:接口名.属性名。
8、接口不可以继承其它类,但是可以继承多个别的接口
interface IB {
void hi();
}
interface IC {
void say();
}
interface ID extends IB,IC {
void say();
}
9、接口的修饰符只能是public 和 默认。
interface IB {
void hi();
}
public interface IC {
void say();
}
3、接口和继承的理解:
1、继承:继承的价值主要在于解决代码复用性和可维护性。
2、接口:价值主要在于设计好各种规范,让其他类去实现这些方法。
当子类继承了父类,就自动拥有了父类的功能,如果子类需要扩展功能,可以通过实现接口的方式扩展,可以理解为:接口是对Java单继承机制的一种补充。
public static void main(String[] args) {
LittleMonkey little = new LittleMonkey("小猴");
little.climbing();
little.flying();
}
interface BirdAble {
void flying()
}
class Monkey {
private String name;
public Monkey(String name) {
this.name = name;
}
public String getName() {
return name;
}
public voic climbing() {
System.out.println( name + "会爬树");
}
}
class LitteMonkey extends Monkey implements BirdAble{
public LitteMonkey(String name) {
super(name);
}
@Override
public void flying() {
System.out.println(getName() + "通过学习,可以像鸟儿一样飞");
}
}
4、接口的多态体现:
public static void main(String[] args) {
// 1、接口的多态体现:
// 接口类型的变量 if01 可以指向实现了IF接口的对象实例
IF if01 = new Method1();
if01 = new Method2();
// 2、继承的多态体现:
// 父类类型的变量 a 可以指向继承AAA 的子类对象实例
AAA a = new BBB();
a = new CCC();
}
interface IF {}
class Method1 implements IF{}
class Method2 implements IF{}
class AAA {}
class BBB extends AAA {}
class CCC extends AAA {}
4.1、多态数组:
public static void main(String[] args) {
/*
在USB数组中存放 phone 和 camera 对象,phone类有一个特有方法call();遍历USB数组,如果是phone对象,除了调用USB接口定义的方法work()外还要调用phone特有方法call():
*/
Usb[] usbs = new Usb[2];
usbs[0] = new Phone();
usbs[1] = new Camera();
for(int i = 0; i < usbs.lenth; i++) {
usbs[i].work();
if(usbs[i] instanceof Phone) { // 判断他的运行类型是phone
({Phone) usbs[i]).call(); // 向下转型
}
}
}
interface Usb{}
class Phone implements Usb{}
class Camera implements Usb{}
4.2、接口多态传递:
public static void main(String[] args) {
// 接口类型变量可以指向,实现了该接口的类的对象实例。
Inter2 inter2 = new Man();
// 如果接口2继承了接口1,而且Man实现了接口2,那么就相当于Man类也实现了接口1
// 这就是所谓的接口多态传递现象:
Inter1 inter1 = new Man();
}
interface inter1{
void hi();
}
interface inter2 extends inter1{} // 接口2继承了接口1
class Man implements inter2{
@Override
public void hi() {} // 也要重写接口1的方法
}
类的5的成员:
1、属性
2、方法
3、构造器
4、代码块
5、内部类