抽象类 & 接口

抽象类 & 接口

    • 抽象类
      • 为什么使用抽象类
      • 抽象类abstract关键字
      • 抽象方法
      • 抽象类特点
      • 抽象类和普通类的区别
      • final和abstract是否可以连用
      • abstract的使用
    • 接口
      • 接口的概念
      • 使用接口的好处
      • 接口的特点
      • 语法
      • interface的实现与使用
      • 接口中特殊的方法
    • 面试题
      • 接口和抽象类有什么区别?
      • 扩展面试题

抽象类

为什么使用抽象类

-有些类创建对象没有意义。需要把这个定义为抽象类
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;

你可能感兴趣的:(Java,抽象类,java,接口)