Java学习（final、抽象类和抽象方法、接口的定义和使用、内部类）

1.final

• 使用final修饰：

1. 方法：表示该方法是最终方法，不能被重写
2. 类：表明该变量是最终类，不能被继承
3. 变量：叫常量，只能被赋值一次

• 细节： 

1. final修饰的变量是基本类型：变量储存的数据值不能发生改变
2. final修饰的引用变量是基本类型：变量储存的地址值不能发生改变，对象内部的可以改变

class fu{
    public final void show(){
        System.out.println("父类show方法");
    }
}

class zi extends fu{
}

 

---

 

2.抽象类和抽象方法

• 抽象类不能实例化

• 抽象类不一定有抽象方法，有抽象方法的类一定是抽象类

• 可以有构造方法

• 抽象类的子类

1. 要么重写抽象类中的所有抽象方法

2. 要么是抽象类 

• 抽象类的作用

抽取共性时，无法确定方法体，就把方法定义为抽象的，强制让子类按照某种格式重写抽象方法所在的类，必须是抽象类

• 抽象类和抽象方法的格式

public abstract 返回值类型 方法名(参数列表)
public abstract class 类名{}

• 继承抽象类有哪些要注意

要么重写抽象类中的所有抽象方法
要么是抽象类

public abstract class Animal {
    public String name;
    public int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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 interface swim {
    public abstract void swim();
    public static void NB(){
        System.out.println("nba");
    }
}

public class Frog extends Animal implements swim{
    public Frog() {
    }

    public Frog(String name, int age) {
        super(name, age);
    }
    @Override
        public void eat() {
            System.out.println("饭");
        }

    }

public class test {
    public static void main(String[] args) {
        Frog f = new Frog("小明",6);
        System.out.println(f.getName()+','+f.getAge());
        f.eat();
    }
}

---

 

 3.接口的定义和使用

• 接口用关键字interface来定义
  public interface 接口名{}
• 借口不能实例化
• 接口和类之间是实现关系，通过implements关键字表示
  public class 类名 implements 接口名 {}
• 接口的子类(实现类)
  要么重写接口中的所有抽象方法
  要么是抽象类

注意1:接口和类的实现关系，可以单实现，也可以多实现。
          public class 类名 implements 接口名1，接口名2 {}
注意2:实现类还可以在继承一个类的同时实现多个接口。
          public class 类名 extends 父类 implements 接口名1，接口名2 {}

接口中成员的特点

• 成员变量

       只能是常量
       默认修饰符: public static final

• 构造方法

         没有

• 成员方法

      只能是抽象方法
      默认修饰符:public abstract

接口和类之间的关系

• 类和类的关系

继承关系，只能单继承，不能多继承，但是可以多层继承

• 类和接口的关系

实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实多个接口

• 接口和接口的关系

继承关系，可以单继承，也可以多继承

• 允许在接口中定义定义静态方法，需要用static修饰

接口中静态方法的定义格式

• 格式:public static 返回值类型 方法名(参数列表){}
• 范例:public static void show(){}

接口中静态方法的注意事项

• 静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
• public可以省略，static不能省略

 

---

 

4.内部类

• 解释：在一个类的里面，再定义一个类。
• 举例:在A类的内部定义B类，B类就被称为内部类
• 注意：内部类表示的事物是外部类的一部分，内部类单独出现没有任何意义

内部类的访问特点

• 内部类可以直接访问外部类的成员，包括私有
• 外部类要访问内部类的成员，必须创建对象

public class Car(){ //外部类
    String carName;
    int carAge;
    int carColor;

    class Engine{  //内部类
        String engineName;
        int engineAge;
    }
}