抽象类和接口

一只小菜鸟YZXCN

已于 2022-11-23 09:04:06 修改

阅读量605

点赞数 1

分类专栏： Java基础知识文章标签： java

于 2022-11-23 09:01:29 首次发布

本文链接：https://blog.csdn.net/m0_48207512/article/details/127333187

版权

Java基础知识专栏收录该内容

19 篇文章 3 订阅

订阅专栏

.一、抽象类

一、抽象类定义和特点

抽象类：abstract关键字修饰的类

抽象方法：abstract关键字修饰的方法

格式：

public abstract class 类名（）{

public abstract 返回值类型方法名 (【参数】);

代码

}

package test;
//抽象类
public abstract class Animal {
	//抽象方法
	public abstract void eat(); 
	
}

注意：

（1）抽象方法没有方法体

（2）一个类中如果有抽象方法，那么该类一定是抽象类

二、抽象类成员特点

特点：

（1）抽象方法没有方法体。

（2）抽象类中成员变量可以是变量和常量。

（3）抽象类和抽象方法必须使用abstract关键字。

（4）抽象类中可以不包含抽象方法，有抽象方法的类一定是抽象类。

（5）抽象类中子类要么重写父类中所有的抽象方法，要么子类也是抽象类。

（6）抽象类不是具体的，不能创建对象，但可以参考多态的方式，通过子类创建对象。

（7）抽象类中的方法可以定义抽象方法、成员方法、构造方法、set/get方法和重写后的toString()方法

注意：抽象类中的抽象方法作用：限定子类做什么事

范例代码：

//父类
package test;
//定义抽象类
public abstract class Animal {
	//成员变量
	private String name;
	private int age;
	
	
	//无参构造方法
	public Animal() {
		super();
	}
	
	//有参构造方法
	public Animal(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	//set/get方法
	public String getName() {
		return name;
	}


	public void setName(String name) {
		this.name = name;
	}


	public int getAge() {
		return age;
	}


	public void setAge(int age) {
		this.age = age;
	}


	//抽象方法
	public abstract void eat();
	
	//成员方法
	public void method() {
		
		System.out.println("昵称:"+this.name+" "+"年龄："+this.age);
		
	}
}

//子类
package test;
//子类继承父类
public class Cat extends Animal {  
	
	//无参构造方法
	public Cat() {
		super();//继承父类无参构造方法
	}
	
	//有参构造方法
	public Cat(String name, int age) {
		super( name, age); //继承父类有参构造方法
		
	}
	
	//重写父类后的抽象方法
	@Override 	//注解  
	public void eat() {
		System.out.println("猫爱吃鱼");
	}
	
}

//测试类
package test;

public class AnimalTest {

	public static void main(String[] args) {
		
		//抽象类可以参照多态的形式创建对象
		Animal animal = new Cat(); 
		animal.setName("汤姆");
		animal.setAge(4);
		
		//调用父类中的成员方法
		animal.method();
	
		//调用子类重写父类后的抽象方法
		animal.eat();
		
		//有参构造方法
		Animal animal1 = new Cat("加菲",5);
		
		//调用父类中的成员方法
		animal1.method();
		//调用子类重写父类后的抽象方法
		animal.eat();
		
	}

}

二、接口

一、接口的格式和特点

定义：内部所有方法都是抽象方法的类

格式：

public interface 接口名{

代码

}

特点：

1.接口是一种特殊的抽象类

2.使用interface关键字声明接口

4.接口中所有的方法都是抽象方法

5.接口命名方法采用大驼峰命名法

package test;

public interface Door {
	
	//开门
	public void openDoor(); //抽象方法
	
	//锁门
	public void closeDoor(); //抽象方法
	
}

二、类实现接口

格式：

public class 类名 implements 接口1，接口2，...，接口n{

代码

}

特点：

  （1）实现类使用implements关键字实现接口。

        （2）实现类实现接口时要重写接口中的所有抽象方法。

  （3）实现类实现多个接口时，接口和接口之间用逗号隔开。

（4）抽象类实现接口时，可以不用重写接口中的所有抽象方法。

注意：

实现类和接口之间是是实现关系，类和类之间是继承关系，接口和接口之间是继关系。

范例：

Lock接口：

package test;
//接口
public interface Lock {
	
	//抽象方法
	public void openLock();
	
	//抽象方法
	public void closeLock();
}

Door接口：

package test;
//接口
public interface Door {
	
	//抽象方法
	public void openDoor();
	
	//抽象方法
	public void closeDoor();
	
}

实现类：

package test;
//实现类实现接口
public class AntiTheftDoor implements Lock,Door {  //类实现多个接口时，接口和接口之间用逗号隔开
	
	//重写Lock接口中的方法
	@Override
	public void openLock() {
		System.out.println("开锁");
		
	}

	@Override
	public void closeLock() {
		System.out.println("上锁");
		
	}
	
	//重写Door接口中的方法
	@Override
	public void openDoor() {
		System.out.println("开门");
		
	}

	@Override
	public void closeDoor() {
		System.out.println("锁门");
		
	}
	
}

测试类：

package test;
//测试类
public class Test {

	public static void main(String[] args) {
		
		//接口无法直接创建对象
		//Door door = new Door(); 
		
		//接口可以参照多态的方式创建对象
		
		//创建接口引用指向类对象
		Door door = new AntiTheftDoor(); 	
		door.openDoor();  //开门
		door.closeDoor(); //锁门
		
		//创建接口引用指向类对象
		Lock lock = new AntiTheftDoor();
		lock.openLock();  //开锁
		lock.closeLock(); //上锁
	}

}

三、接口中的成员特点

特点：

（1）接口中的属性全部都是静态常量，默认修饰符 public static final。

（2）接口中所有的方法都是抽象方法，所有方法默认都是 public abstract。

package test;
//接口
public interface Door {
	//属性
	public int height = 2000;
	
	public final int width = 1000;
	
}

package test;
//测试类
public class Test {

	public static void main(String[] args) {
	
		//创建接口引用指向类对象
		Door d = new AntiTheftDoor();
		
		//调用属性
		int result1 = d.height;
		System.out.println(result1); //2000
		
		int result2 = d.width;
		System.out.println(result2); //1000
		
		//赋值
		d.width = 20;    
		d.height = 1000; 
		/* 分析:
		 * 	 width是被final修饰的常量其值固定不变,不能被重新赋值,所以报错！
         *而height量被重新赋值也报错 说明height也是常量,间接说明接口中的量
         *都是常量,默认被final关键字修饰。
		 * */
		
		int result3 = Door.width;
		System.out.println(result3); //2000
		
		int result4 = Door.height;
		System.out.println(result4); //1000
		
		/*分析:
		 * 	 width属性和height属性,可以通过类名调用,可以说明width和height默认
         *被static关键字修饰,只有被static修饰的量才可以通过类名的方式,间接说明
		 *接口中的量默认被static关键字修饰。
		 *
		 * */
		
		/*总结：
		 *（1）接口中的属性全部都是静态常量，默认修饰符 public static final。
		 *（2）接口中所有的方法都是抽象方法，所有方法默认都是 public abstract。
		 * */
		
	}

}