抽象类 & 接口

抽象类

为什么使用抽象类

-有些类创建对象没有意义。需要把这个定义为抽象类
exp:
1 Animal animal=new Animal();
2 Pet pet=new Pet()
这里的动物类就比较抽象，该类创建对象无意义。
使用abstract修饰类变成抽象类：不能实例化，只能被继承
抽象类的构造方法不能直接使用，只能被子类调用。

抽象类abstract关键字

可以修饰方法：叫做抽象方法，没有方法体，需要使用分号表示声明结束，抽象方法所在的类必须是抽象类
子类必须重写父类的抽象方法，除非子类也是抽象类

抽象方法

使用abstract关键字修饰，只表示声明了一个方法，但是没有任何的实现
特点：
1）没有方法体，需要使用分号表示方法声明结束
2）如果一个类中有一个方法是抽象的，那么这个类必须是抽象的
3）抽象方法必须被子类重写，除非子类也是抽象类

抽象类特点

1）抽象类中可以包含抽象方法，也可以包含普通方法。
2）抽象类中有构造方法，但是不能创建对象，构造方法目的在子类中会被调用。
3）抽象类的存在就是为了被继承，子类必须重写父类的抽象方法，除非子类也是抽象类。

抽象类和普通类的区别

1）抽象类需要abstract，而普通类不需要
2）构造方法：都有，但是抽象类不能实例化对象，普通类可以
3）成员方法：抽象类中可以存在抽象的成员方法也可以存在非抽象成员方法，而普通类中只能存在非抽象成员方法

final和abstract是否可以连用

1）两个关键字修饰方法时，final修饰的方法特点：可以被继承不能被重写；abstract修饰的方法特点：必须被重写；所以这两个关键字不能同时修饰同一个方法

2）两个关键字修饰类时：final修饰的类特点：不能被继承；abstract修饰的类特点：必须被继承；所以这两个关键字不能同时修饰同一个类

综上所述：final和abstract不可以连用
final的类中能否有abstract方法？不能
abstract类中能否有final方法？可以

abstract的使用

package com.qf.day11;
/**
 * 宠物类
 */
public abstract class Pet {
	//编号
	private int id;
	//宠物昵称
	private String name;
	//健康值
	private int health;
	//亲密度
	private int love;
	
	//alt+/
	public Pet() {
	}
	//alt+shift+s --》Generate constructor using field
	public Pet(int id, String name, int health, int love) {
		super();
		this.id = id;
		this.name = name;
		this.health = health;
		this.love = love;
	}
   //setter and getter
	/**
	 * 抽象方法，没有方法体,
	 * 子类必须重写抽象方法
	 */
	public abstract void print();
	//父类的吃的方法
	public void eat() {
		System.out.println("宠物吃东西");
		int h=getHealth();
		setHealth(h+2);
	}
}

package com.qf.day11;

public  class Dog extends Pet{
	private String strain;
	
	 //setter and getter

	public Dog() {
		// TODO Auto-generated constructor stub
	}

	public Dog(int id, String name, int health, int love,String strain) {
		super(id, name, health, love);
		this.strain=strain;
	}

	@Override
	public void print() {
		System.out.println("狗狗信息：编号:"+super.getId()+" 昵称:"+super.getName()+" 健康值:"+getHealth()+" 亲密度:"+getLove()+" 品种:"+strain);
	}
}


package com.qf.day11;

public class Test {
	public static void main(String[] args) {
		//Pet pet=new Pet();
		Pet pet=new Dog(100,"大黄",100,90,"哈士奇");
		pet.eat();
		pet.print();
	}
}

接口

接口的概念

从语法上讲：
接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有方法的实现。
从功能上讲：接口表示一种约定或能力

使用接口的好处

扩展类的功能,保持对外接口一致
接口实现了多重继承，完成类和任何实现接口子类的通信和交互
降低代码之间的耦合性

接口的特点

1）接口不能创建对象，而且接口中没有构造方法；

2）接口中的方法一般都是共有抽象方法：public abstract

3）接口中所有的属性都是共有静态常量属性：pulbic static final

在一个接口中声明方法时:
若没有声明访问权限，默认也是public，
若没其他修饰默认也是abstract；
声明属性时:
若没有声明访问权限和静态常量，默认也是public static final

语法

语法：
public interface 接口名{
	//接口中的成员：抽象方法和静态常量
}

pulbic interface I{
	public abstract void fun();
}

public class Impl implements I {
	public void fun(){}
}

必须先继承再实现接口
public class Dog extends Animal implements I{
  	public void fun(){}
}

interface的实现与使用

package com.qf.day11_4;

public class Test {
	public static void main(String[] args) {
		Computer lenovo=new Computer();
		Mouse luoji=new Mouse();
		Upan jinshidui=new Upan();
		Fan  meidi=new Fan();
		
		//通过接口把设备连接到电脑上
		lenovo.usb1=luoji;
		lenovo.usb2=jinshidui;
		lenovo.usb3=meidi;
		
		
		lenovo.work();
		
//		USB usb=new Mouse();//向上转型
//		USB usb2=new Upan();
//		USB usb3=new Fan();
	}
}

package com.qf.day11_4;

public class Computer {
	//三个usb接口
	USB usb1;
	USB usb2;
	USB usb3;
	
	//运行
	public void work() {
		System.out.println("电脑启动成功");
		if(usb1!=null) {
			usb1.service();
		}
		if(usb2!=null) {
			usb2.service();
		}
		if(usb3!=null) {
			usb3.service();
		}
	}
}

package com.qf.day11_4;

public interface USB {
	void service();//服务
}


package com.qf.day11_4;

public class Fan implements USB {

	@Override
	public void service() {
		System.out.println("风扇和电脑连接成功，开始吹风.....");
	}
}

package com.qf.day11_4;
/**
 * 鼠标
 *
 */
public class Mouse implements USB {
	@Override
	public void service() {
		System.out.println("鼠标和电脑连接成功，开始工作....");
	}
}

package com.qf.day11_4;
/**
 * U盘 
 *
 */
public class Upan implements USB{

	@Override
	public void service() {
		System.out.println("U盘和电脑连接成，开始传输数据");
	}

}

接口中特殊的方法

1）jdk1.8之后接口中使用static关键字修饰的方法有方法体
2）jdk1.8之后接口中使用default关键字修饰的方法有方法体

package com.qf.day11_3;
/**
 * USB接口
 * 包含 抽象方法
 * 常量
 * 
 * 扩展：jdk 1.8
 * 接口中可以包含 默认方法 和 静态方法
 */
public interface USB {
	//抽象方法
	//充电
	public abstract void charge();
	//传输数据
	void transData();
	
	//常量
	int num=4;
	//静态方法
	public static void method1() {
		
	}
	//默认方法
	public default void method2() {
		
	}
}

面试题

接口和抽象类有什么区别?

语法:

1>抽象类使用abstract，接口使用interface

2>抽象类中可以包含抽象方法，也可以包含非抽象方法，接口中只能包含抽象方法和静态常量，jdk1.8之后接口可以包含静态方法和默认方法注意同时须有方法体。

3>抽象类和接口都不能实例化。

4>抽象类可以包含构造方法，接口中没有构造方法。

功能：

1>抽象类一般用来表示同类事物，接口可以表示不是同类事物。

2>抽象类可以实现代码的重用，也可以约束子类的功能。接口就是约束实现类的功能，降低代码之间的耦合性。

扩展面试题

int i=10;
i=i++;
System.out.println(i);
//输出i=10;
理解：i++看成是一个整体。
等价于 int k=i++;
i=k;

int k=0;
int i=10;
while(k<100){
i=i++; k++;
}
System.out.println(i);
//输出i=10;