抽象类 abstract关键字
抽象方法: 没有方法体的方法
抽象类: 含有抽象方法的类,抽象类可以理解为一个只有方法声明没有方法体的特殊类
特点:
1．通过 abstract 关键字实现
2. 可修饰 方法 或 类
3. 抽象类中可以没有抽象方法
4. 如果类中有抽象方法,那该类必须定义为一个抽象类
5. 子类继承了抽象类后,要么还是一个抽象类,要么就把所有抽象方法重写
6. 抽象类多用于 多态中
7. 抽象类不能被实例化
public class Test1 {
public static void main(String[] args) {
// Animal a = new Animal();//抽象类不能被实例化
Animal a2 = new Cat();
a2.eat();
a2.game();
a2.sleep();
}
}
// 2.如果一个类中,包含抽象方法那么这个类必须是个抽象类
abstract class Animal{
abstract public void eat();// 1.抽象方法
public void sleep(){
System.out.println("正在睡觉");
}
abstract public void game();
}
// 3.子类继承了一个抽象类后,可以抽象的子类,也可以是普通的子类(需要把所有抽象方法都重写)
abstract class Dog extends Animal{}
// 4.Dog 已经把父类的所有方法都继承过来了,此时包含抽象方法
class Cat extends Animal{
public void eat(){
System.out.println("猫吃鱼");
}
public void game(){
System.out.println("猫玩耗子");
}
}
抽象类构造方法使用
public class Test2 {
public static void main(String[] args) {
// 3.创建子类对象时,为什么会触发父类的无参构造?--因为子类无参构造中,隐藏着 super()
AbstractDemo a = new AbstractDemo2();
//4.抽象类不能创建对象的,那还提供构造方法干什么呢?--不是为了自己创建对象,而是为了子类创建对象用
// AbstractDemo demo2 = new AbstractDemo();
}
}
abstract class AbstractDemo{
// 1.提供构造方法
public AbstractDemo(){
System.out.println("AbstractDemo...无参构造");
}
// 2.如果抽象类中,没有抽象方法也就是都是普通方法,那么这个类修饰成普通类就行,为什么还有被修饰成抽象类?
// 目的就是不让外界 创建对象
}
class AbstractDemo2 extends AbstractDemo{
public AbstractDemo2(){
//3.1 子类的无参构造中,第一条语句隐藏着 super()
super();
System.out.println("AbstractDemo2..无参构造");
}
}
抽象类 成员变量使用
在抽象类中,既可以包含变量,也可以包含常量
public class Test3 {
public static void main(String[] args) {
AbstractDemo3 demo = new AbstractDemo4();
System.out.println(demo.sum);
// System.out.println(demo.MIN_VALUE);
System.out.println(AbstractDemo3.MIN_VALUE);
}
}
abstract class AbstractDemo3{
//在抽象类中,可以包含变量,也可以包含常量
int sum = 10;
static final int MIN_VALUE = -128;
}
class AbstractDemo4 extends AbstractDemo3{}
抽象类 成员方法的使用
抽象类中 既可以包含普通方法,也可以包含抽象方法
public class Test4_UseAbstract3 {
public static void main(String[] args) {
AbstractDemo5 demo = new AbstractDemo6();
demo.eat();
demo.play();
demo.study();
}
}
//抽象类可以有普通方法,也可以有抽象方法
abstract class AbstractDemo5{
public void eat(){
System.out.println("大家吃的都是一样的");
}
public abstract void play();
abstract public void study();
}
class AbstractDemo6 extends AbstractDemo5{
@Override
public void play(){
System.out.println("人生苦短,我学java");
}
@Override
public void study(){
System.out.println("好好学习");
}
}
接口 interface关键字
java 中不允许多重继承,可通过实现多个接口来实现多个类的功能.
java 接口 和 java 抽象类型代表的是抽象类型,是 抽象层 的具体表现.
接口的特点
- 接口中 都是 抽象方法
- 通过 interface 关键字创建 接口
- 通过 implements 关键字让子类 实现 接口
- 接口 是 一个 特殊 的 抽象类
- 接口 打破了 java 单继承 的 局限
- 接口 和 类 之间 可以多实现, 接口 和 接口 之间 可以 多继承
- 接口 是 对外 暴露 的 规则, 是一套 开发规范
- 接口 提高了 程序 的 功能扩展,降低了 耦合性
public class Test5 {
public static void main(String[] args) {
// 5.创建多态对象测试
inter1 in = new inter1impl();
in.save();
in.update();
}
}
// 1.定义接口 interface
interface inter1{
// 2.接口是一个抽象类,特殊在接口里都是抽象方法
abstract public void save();
abstract public void update();
}
// 3.通过implements,使用接口的功能
// 4.接口是一个特殊的抽象类,实现类的用法和继承时子类的用法一样
// 实现类还是两条路,要么是抽象的实现类,要么重写所有抽象方法
//abstract class inter1impl implements inter1{
class inter1impl implements inter1{
@Override
public void save(){
System.out.println("正在保存数据");
}
@Override
public void update(){
System.out.println("正在更新数据");
}
}
注: 接口 子类命名规则为接口名 + impl
接口 的用法
- 接口 没有 构造方法
- 接口 没有成员变量,都是常量 ,定义一个变量没有写修饰符时,
默认会加上public static final - 接口 里的 方法,默认就是 抽象方法,如果不写明是 abstract 的,会自动补齐
如写void save(); 会自动补齐为 public abstract void save();
public class Test6 {
public static void main(String[] args) {
inter2 demo = new inter2impl();
// System.out.println(demo.age);
// demo.age = 20;
System.out.println(inter2.age);//证明变量是 static 的
}
}
interface inter2{
//1.接口不可以存在 构造方法
// public inter2(){}
//2.接口里没有成员变量,接口里都是静态的常量,会为变量自动拼接 public static final
// public static final int age = 30;
int age = 30;//简写
//3.接口里的成员方法? --不能是普通方法,都是抽写方法,会为方法自动拼接 public abstract
// public abstract void save();
void save();
}
class inter2impl implements inter2{
@Override
public void save(){
System.out.println("正在保存数据");
}
}
