【JAVASE_学习笔记】抽象类与接口

【JAVASE_学习笔记】抽象类与接口

final关键字

final表示最终
注意：
　　　1.final修饰一个基本类型变量时，该变量不能被重新赋值
　　　　　常量的修饰符为：public static final
　　　2.final修饰一个引用类型变量时，该引用不能重新指向新的对象
　　　3.final修饰一个方法时，该方法不能被重写
　　　4.final修饰一个类时，该类不能被继承
举例：

final class Circle{
    double r;
    public  static  final double PI = 3.14; // 常量
    //构造函数
    public Circle(double r){
        this.r = r;
    }
    public Circle(){}
    public final void getArea(){
        System.out.println("面积是："+ PI*r*r);
    }
}

class Demo3 {
    public static void main(String[] args) 
    {
        final Circle c = new Circle(3.0);
        //c = new Circle();//报错
        print(c);//不会报错
    }
    public static void  print(final Circle c){
        //c  = new Circle(4.0);  // c指向了新的对象。
    }
}

abstract（抽象）类

描述一类事物时，发现该事物确实存在着某种行为，但目前该行为是不具体的，这时应该抽取该方法的声明，不去实现该方法，这时应使用抽象类。
注意：
　　　1.如果一个方法没有方法体，那么该方法必须使用abstract修饰
　　　2.如果一个类有抽象的方法，该类也必须用abstract修饰
　　　3.非抽象类继承抽象类时，必须把抽象类中的所有抽象方法全部实现
　　　4.抽象类可以定义抽象方法以及非抽象方法
　　　5.抽象类可以不存在抽象类
　　　6.抽象类不能创建对象
　　　7.抽象类是存在构造方法的（留给子类调用初始化父类继承的成员变量）
抽象类的成员特点：
　　　　成员变量:
　　　　　　可以是变量也可以是自定义常量
　　　　构造方法:
　　　　　　抽象类可以有构造方法:包括有参构造和无参构造
　　　　　　作用:通过抽象类多态的形式:让子类进行数据的初始化
　　　　成员方法:
　　　　　　可以有抽象方法,也可以有非抽象方法
　　　　　　抽象方法:强制子类必须要做到一件事情:方法重写(覆盖)
　　　　　　非抽象方法:由继承保证可以去提高代码的复用性
abstract不能和以下关键字配合使用：
　　1.不能和private配合使用
　　2.不能和final配合使用
　　3.不能和static配合使用
举例：

//测试类
public class Demo1 {
    public static void main(String [] args){
        Rectangle r=new Rectangle(3,4);
        System.out.println(r.areaMath());//12.0
        System.out.println(r.perimeterMath());//14.0
        Circle c=new Circle(1.0);
        System.out.println(c.areaMath());//3.14
        System.out.println(c.perimeterMath());//6.28
    }

}
//图形类  抽象
abstract class Graph{
    public abstract double areaMath();
    public abstract double perimeterMath();
}
//矩形类
 class Rectangle extends Graph{
    int shortLength;
    int longLength;
    public Rectangle(int shortLength,int longLength){
        this.shortLength=shortLength;
        this.longLength=longLength;
    }
    //方法重写：返回值类型要与抽象方法一致，或是抽象方法返回值类型的子类
    public double areaMath() {
        int area=shortLength*longLength;
        return area;
    }
    public double perimeterMath() {
        int perimeter=(shortLength+longLength)*2;
        return perimeter;
    }
}
//圆形类
 class Circle extends Graph{
    double r;
    //常量要用public static final修饰
    public static final double PI=3.14;
    public Circle(double r){
        this.r=r;
    }
    public double areaMath() {
        double area=PI*r*r;
        return area;
    }
    public double perimeterMath() {
        double perimeter=PI*r*2;
        return perimeter;
    }
}

接口

接口的定义格式：

interface 接口名{

}

接口子实现类的一般命名规范：接口名+impl
实现接口的格式：

class 接口 implements 接口{

}

注意：
　　　1.接口其实是一个特殊的类
　　　2.接口中的成员变量都属于常量，默认修饰符：public static final
　　　3.接口中的方法都是抽象的方法，默认修饰符：public abstract
　　　4.接口是不能用于创建对象的
　　　5.接口是没有构造方法的，因为接口中的变量都是常量，接口中的方法都是抽象的方法
　　　6.一个非抽象类实现一个接口时，必须实现接口中的所有方法
接口的作用：
　　　1.拓展功能
　　　2.定义约束规范
　　　3.程序的解耦
接口与类之间的关系：实现关系
　　　1.非抽象类实现一个接口时，必须要把接口中的所有方法都实现
　　　2.一个类可以实现多个接口

class 类名 implements 接口1，接口2，...

　　　3.抽象类实现接口时，可以实现接口中的方法，也可以不实现接口中的方法
接口和接口之间的关系：继承关系
　　　一个接口可以继承多个接口

interface B extends A,C

接口与抽象类间的区别：
　　1)成员的区别
　　　　成员变量：抽象类：成员变量可以是常量也可以是变量
　　　　　　　　　接　口：成员变量只能是常量，默认修饰符为：public static final
　　　　构造方法：抽象类：可以有无参构造、有参构造方法
　　　　　　　　　　　　　作用：通过子类进行数据初始化（通过子类创建对象）
　　　　　　　　　接　口：没有构造方法
　　　　成员方法：抽象类：可以有抽象方法，也可以有非抽象方法
　　　　　　　　　接　口：只能是抽象方法。默认修饰符为：public abstract
　　2)关系的区别
　　　　类与类的关系：extends，Java中只存在单继承，不支持多继承，但支持多层继承
　　　　类与接口：implements，一个类在继承另一个类的同时可以实现多个接口
　　　　接口与接口：继承关系，可以单继承也可以多继承
　　3)设计理念
　　　　抽象类：体现的是一种“is a”关系，存在继承关系
　　　　接口：体现的是“like a”关系，扩展功能
举例：

//测试类
public class Demo2 {
    public static void main(String [] args){
        Student s=new Student("张三",18);
        s.study();//18岁的张三学习啦
        SomeStudent ss=new SomeStudent("李四",23);
        ss.study();//23岁的李四学习啦
        ss.getMoney();//23岁的李四赚钱啦
    }

}
//父类
class Student {
    String name;
    int age;
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void study(){
        System.out.println(age+"岁的"+name+"学习啦");
    }
}
//接口
interface GetMoney{
    public void getMoney();
}
//子实现类
class SomeStudent extends Student implements GetMoney{
    public SomeStudent(String name,int age){
        super(name,age);
    }
    public void getMoney(){
        System.out.println(age+"岁的"+name+"赚钱啦");
    }
}