重生之我在deepseek中学习java 第五天-Java-E先生的博客

Java学习指南-第五天：抽象类与接口

　　1.抽象类

　　抽象类是不能被实例化的类，通常用于作为其他类的基类。抽象类可以包含抽象方法（没有实现的方法）和具体方法（有实现的方法）。

　　1.1定义抽象类　　

public abstract class Animal{
　　String name;
　　public Animal(String name){
　　this.name=name;
　　}
　　//抽象方法
　　public abstract void makeSound();
　　//具体方法
　　public void eat(){
　　System.out.println(name+"is eating.");
　　}
　　}

　　1.2继承抽象类

　　子类必须实现抽象类中的所有抽象方法，除非子类也是抽象类。

　　public class Dog extends Animal{
　　public Dog(String name){
　　super(name);
　　}
　　 Override
　　public void makeSound(){
　　System.out.println(name+"is barking.");
　　}
　　}
　　public class Main{
　　public static void main(String[]args){
　　Dog myDog=new Dog("Buddy");
　　myDog.makeSound();//输出:Buddy is barking.
　　myDog.eat();//输出:Buddy is eating.
　　}
　　}

　　2.接口

　　接口是一种完全抽象的类，只包含抽象方法和常量（public static final）。接口用于定义一组方法规范，实现接口的类必须实现这些方法。

　　2.1定义接口　　

　　public interface Vehicle{
　　void start();
　　void stop();
　　}

　　2.2实现接口

　　类使用implements关键字实现接口，并必须实现接口中的所有方法。

　　public class Car implements Vehicle{
　　 Override
　　public void start(){
　　System.out.println("Car is starting.");
　　}
　　 Override
　　public void stop(){
　　System.out.println("Car is stopping.");
　　}
　　}
　　public class Main{
　　public static void main(String[]args){
　　Car myCar=new Car();
　　myCar.start();//输出:Car is starting.
　　myCar.stop();//输出:Car is stopping.
　　}
　　}

　　3.接口的多重实现

　　Java支持一个类实现多个接口，从而实现多重继承的效果。

　　public interface Drivable{
　　void drive();
　　}
　　public interface Flyable{
　　void fly();
　　}
　　public class FlyingCar implements Drivable,Flyable{
　　 Override
　　public void drive(){
　　System.out.println("Flying car is driving.");
　　}
　　 Override
　　public void fly(){
　　System.out.println("Flying car is flying.");
　　}
　　}
　　public class Main{
　　public static void main(String[]args){
　　FlyingCar myFlyingCar=new FlyingCar();
　　myFlyingCar.drive();//输出:Flying car is driving.
　　myFlyingCar.fly();//输出:Flying car is flying.
　　}
　　}

　　4.默认方法和静态方法

　　从Java 8开始，接口可以包含默认方法和静态方法。

　　4.1默认方法

　　默认方法提供方法的默认实现，实现类可以选择重写或直接使用。

　　public interface Vehicle{
　　void start();
　　void stop();
　　default void honk(){
　　System.out.println("Honking the horn.");
　　}
　　}
　　public class Car implements Vehicle{
　　 Override
　　public void start(){
　　System.out.println("Car is starting.");
　　}
　　 Override
　　public void stop(){
　　System.out.println("Car is stopping.");
　　}
　　}
　　public class Main{
　　public static void main(String[]args){
　　Car myCar=new Car();
　　myCar.start();//输出:Car is starting.
　　myCar.stop();//输出:Car is stopping.
　　myCar.honk();//输出:Honking the horn.
　　}
　　}

　　4.2静态方法

　　静态方法属于接口本身，不能被子类或实现类继承。

　　public interface Vehicle{
　　void start();
　　void stop();
　　static void service(){
　　System.out.println("Vehicle is being serviced.");
　　}
　　}
　　public class Main{
　　public static void main(String[]args){
　　Vehicle.service();//输出:Vehicle is being serviced.
　　}
　　}

　　5.今日任务

定义一个抽象类Shape，包含抽象方法calculateArea和具体方法display。
定义两个子类Circle和Rectangle，分别实现calculateArea方法。
定义一个接口Drawable，包含方法draw，并让Circle和Rectangle实现该接口。
使用多态创建Shape类型的对象数组，调用calculateArea和draw方法。

　　6.示例代码　

　　public abstract class Shape{
　　public abstract double calculateArea();
　　public void display(){
　　System.out.println("This is a shape.");
　　}
　　}
　　public interface Drawable{
　　void draw();
　　}
　　public class Circle extends Shape implements Drawable{
　　double radius;
　　public Circle(double radius){
　　this.radius=radius;
　　}
　　 Override
　　public double calculateArea(){
　　return Math.PI*radius*radius;
　　}
　　 Override
　　public void draw(){
　　System.out.println("Drawing a circle.");
　　}
　　}
　　public class Rectangle extends Shape implements Drawable{
　　double width;
　　double height;
　　public Rectangle(double width,double height){
　　this.width=width;
　　this.height=height;
　　}
　　 Override
　　public double calculateArea(){
　　return width*height;
　　}
　　 Override
　　public void draw(){
　　System.out.println("Drawing a rectangle.");
　　}
　　}
　　public class Main{
　　public static void main(String[]args){
　　Shape[]shapes=new Shape[2];
　　shapes[0]=new Circle(5.0);
　　shapes[1]=new Rectangle(4.0,6.0);
　　for(Shape shape:shapes){
　　shape.display();
　　System.out.println("Area:"+shape.calculateArea());
　　if(shape instanceof Drawable){
　　((Drawable)shape).draw();
　　}
　　}
　　}
　　}

　　7.总结

　　今天的内容涵盖了抽象类和接口的定义与使用，以及默认方法和静态方法。这些是Java面向对象编程的重要概念，务必熟练掌握。明天我们将深入学习异常处理。

　　提示：多动手编写代码，尝试定义不同的抽象类和接口，并实现它们。这将帮助你更好地理解抽象类和接口的使用场景。

　　祝你学习愉快！