Java入门(八)

面向对象

final关键字

表示最终，可以用来修饰类，变量，和方法

修饰类：表示最终类，不能被继承

修饰变量：表明该变量是常量，不能再次被赋值

修饰方法：表明该方法是最终方法，不能被重写

Static关键字

静态的意思，可以修饰成员变量和成员方法

• 被类的所有对象共享
• 可以通过类访问，也可以通过对象访问
• 优先于对象存在
• 随着类的加载而加载

public class DuoTaiDemon {
    public static void main(String[] args){
        Animal.color = "yellow";
        Animal a = new Animal();
        a.age = 1;
        a.name = "cat";
        a.show();

        Animal b = new Animal();
        b.age = 2;
        b.name = "dog";
        b.show();
    }
}

public class Animal {
    public int age;
    public String name;
    public static String color;

    public void show(){
        System.out.println(age+" "+name+" "+color);
    }
}

非静态的成员方法：

1. 能访问静态的成员变量
2. 能访问非静态的成员变量
3. 能访问静态的成员方法
4. 能访问非静态的成员方法

静态的成员方法：

1. 能访问静态的成员变量
2. 能访问静态的成员方法

⚠️  静态成员方法中不能出现 this，super 这样的关键字

原因是：静态是随着类的加载而加载的，this，super 这样的关键字是随着对象的创建而存在，先进内存的不能访问后进内存的

抽象类

不应该给出具体的体现 而是一个声明即可

public abstract class Animal {
    public abstract void eat();
}

抽象类的特点

1. 抽象类和抽象方法必须用abstract关键字修饰
2. 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
3. 抽象类不能实例化，可以参照多态的方式，子类对象实例化
4. 抽象类的子类要么重写抽象类中的所有抽象方法，要么是抽象类

public abstract class Animal {
    public abstract void eat();
    public void sleep(){
        System.out.println("sleep");
    }
}

public class Cat extends Animal {
    @Override
    public void eat(){
        System.out.println("Cat eat");
    }
}

public class DuoTaiDemon {
    public static void main(String[] args){
        Animal a = new Cat();
        a.eat();
        a.sleep();
    }
}

成员变量：可以是变量也可以是常量

构造方法：有构造方法，作用是什么？用于子类访问父类数据的初始化

成员方法：成员方法可抽象可非抽象，抽象方法用来限定子类必须完成某些动作，非抽象方法用来提高代码的复用性

 

教师类案例

分析：

      基础班老师：

                           成员变量：name，age

                           构造方法：无参，带参

                           成员方法：getXXX(), setXXX(), teach(){}

     

     就业班老师：

                           成员变量：name，age

                           构造方法：无参，带参

                           成员方法：getXXX(), setXXX(), teach(){}

    抽象类老师：

                           成员变量：name，age

                           构造方法：无参，带参

                           成员方法：getXXX(), setXXX(), teach()

抽象类老师

public abstract class Teacher {
    private int age;
    private String name;

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

    public void setName(String n){
        name = n;
    }

    public String getName(){
        return name;
    }

    public void setAge(int a){
        age = a;
    }

    public int getAge(){
        return age;
    }
    public abstract void teach();
}

就业班老师

public class JobTeacher extends Teacher{
    public JobTeacher(){}
    public JobTeacher(String name, int age){
        super(name,age);
    }
    @Override
    public void teach(){
        System.out.println("Job");
    }
}

基础班老师       

public class BasicTeacher extends Teacher{
    public BasicTeacher(){}
    public BasicTeacher(String name, int age){
        super(name,age);
    }
    @Override
    public void teach(){
        System.out.println("basic");
    }
}

 

 

接口                   

Java中的接口是用来体现扩展性的

定义接口用的是 interface 关键字

类和接口之间是实现关系，用 implement 关键字表示

接口不能实例化，参照多态形式使用实现类来实例化

接口的实现类，要么重写接口中的所有抽象方法，要么是一个抽象类

多态类的几种形式：

1. 具体类多态（几乎不用）
2. 抽象类多态（常用）
3. 接口多态（最常用）

接口实例：

public interface Jumping {
    public abstract void jump();
}

public class Cat implements Jumping{
    @Override
    public void jump(){
        System.out.println("jump");
    }
}

public class InterfaceDemo {
    public static void main(String[] args) {
        Jumping j = new Cat();
        j.jump();
    }
}

接口的成员特点

成员变量：有成员变量，而且变量也只能是常量，默认修饰符 public static final

构造方法：没有构造方法

成员方法：有，而且都是抽象的 默认修饰符 public abstract

 

类与类：继承关系，只能单继承，可以多层继承

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

接口与接口：继承关系，可以单继承，也可以多继承

 

抽象类和接口的区别：

成员变量：

1. 抽象类可以是变量也可以是常量，但接口只能是常量
2. 抽象类有构造方法，但是接口没有构造方法
3. 抽象类的成员方法可以是抽象方法也可以是非抽象方法，但是接口只能是抽象方法

设计理念的区别：抽象类中的定义是继承体系的共性功能，接口中定义的是该体系的扩展功能

 

接口练习制猫狗案例

让所有猫狗具有跳高的额外功能

Animal抽象类

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

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

    public void setName(String n){
        name = n;
    }
    public String getName(){
        return name;
    }
    public void setAge(int a){
        age = a;
    }
    public int getAge(){
        return age;
    }

    public abstract void eat();//抽象
}

Jump跳高接口

public interface Jump {
    public abstract void jump();
}

Cat类和Dog类

public class Dog extends Animal implements Jump{
    public Dog(){}
    public Dog(String name, int age){
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("dog eat");
    }

    @Override
    public void jump() {
        System.out.println("dog jump");
    }
}

public class Cat extends Animal implements Jump{
    public Cat(){}
    public Cat(String name, int age){
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("Cat eat");
    }

    @Override
    public void jump() {
        System.out.println("cat jump");
    }
}

测试类

public class InterfaceDemo {
    public static void main(String[] args) {
        Cat a = new Cat();
        a.setAge(2);
        a.setName("TOM");
        System.out.println(a.getAge()+" "+a.getName());
        a.eat();
        a.jump();

        Dog d = new Dog();
        d.setAge(3);
        d.setName("TIM");
        System.out.println(d.getAge()+" "+d.getName());
        d.eat();
        d.jump();
    }
}

 

包

其实就是文件夹，作用是对类进行分类管理

package必须是程序的第一条可执行语句且在一个Java文件中只能有一个

当类不在同一个包下时，使用的时候要加类的全路径名称，但是这样太麻烦了，使用 import 导包功能

 

权限修饰符

private -- 默认 -- protected -- public

在本类中，四种权限都可以访问，但是在同一包下（子类和无关类），只有 private 不能被访问

在不同包下，无关类只能访问 public，但是子类能访问 protected 和 public