面向对象进阶1

1. 包

作用：包就是文件夹，用来管理各种不同功能的Java类，翻遍后期代码维护。

包名的规则：公司域名反写+包的作用，需要全部英文小写，见名知意。

包名+类名，称为全类名或者全限定名。

使用其它类时，需要使用全类名.

这样使用太麻烦，如何解决？

使用import关键字

使用其它类的规则： 使用同一个包中的类时，不需要导包。

使用java.lang包中的类时，不需要导包。

其它情况都需要导包

如果同时使用两个包中的同名类，需要使用全类名。

2. final

最终的，不可改变的

2.1 final 修饰 方法

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

2.2 final 修饰类

表明该类是最终类，不能被继承

2.3 final 修饰变量

此时称为常量，只能被赋值一次

常量： 实际开发中，常量一般作为系统的配置信息，方便维护，提高可读性。

常量的命名规范：

单个单词：全部大写

多个单词：全部大写，单词之间用下划线隔开

细节： final 修饰的变量是基本类型时：那么变量存储的数据值不能发生改变。

final修饰的变量时引用类型时：那么变量存储的地址值不能发生改变，对象内部的可以改变。

核心：

常量记录的数据不可比变。

3. 权限修饰符

权限修饰符：是用来控制一个成员能够被访问的范围的。

可以修饰成员变量，方法，构造方法，内部类

使用规则： 实际开发中，一般只用private和public

成员变量一般私有

方法公开

特例：如果方法中的代码时抽取其它方法中共性代码，这个方法一般也私有。

4. 代码块

4.1 局部代码块

{int a = 10;}

提前结束变量的生命周期，为了快速释放变量，节约空间。（已淘汰）

4.2 构造代码块

写在成员位置的代码块

private int age;

{}

作用：可以把多个构造方法中重复的代码抽取出来

执行时机；我们在创建本类对象的时候会先执行构造代码再执行构造方法。

缺点：不够灵活

解决办法

4.3 静态代码块

模式：static{}

特点：需要通过static关键字修饰，随着类的加载而加载，并且自动触发，只执行一次。

5 抽象类

子类在继承父类时，有些方法需要重写，此时为了提醒子类重写方法，就用到抽象类。

5.1 抽象类的定义格式

抽象类：如果一个类中存在抽象方法，那么该类就必须声明为抽象类

定义格式： public abstract class 类名{}

5.2 抽象方法的定义格式

抽象方法：将共性的行为（方法）抽取到父类之后。由于每一个子类执行的内容时是不一样的，所以，在父类中不能确定具体的方法体。

该方法就可以定义为抽象方法

定义格式：
public abstract 返回值类型 方法名（参数列表）;

使用举例：
package abstact.demo1;
​
public abstract class Person {
    public abstract void work();
}

抽象类和抽象方法的注意事项： 抽象类不能实例化（不能创建对象）

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

抽象类可以有构造方法。（有什么作用）

抽象类的子类

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

要么子类本身也是抽象类

代码演示：重写抽象类中的所有抽象方法
package abstact.demo1;
​
public class Student extends Person {
    @Override
    public void work() {
        System.out.println("Student work");
    }
}

代码演示:子类本身也是抽象类
package abstact.demo1;
​
public abstract class Teacher extends Person {
​
}

练习：

动物类：
package abstact.demo2;

public abstract class Animal {
    private String name;
    private 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 void drink(){
        System.out.println("Drinking animal");
    }
    public abstract void eat();
}

青蛙类：
package abstact.demo2;

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

    public Frog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("青蛙在吃虫子。");
    }
}

狗类：
package abstact.demo2;

public class Dog extends Animal {
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

山羊类：
package abstact.demo2;

public class Goat extends Animal {
    public Goat() {
    }

    public Goat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("山羊在吃草");
    }
}

测试类：
package abstact.demo2;

public class Test {
    public static void main(String[] args) {
        //创建对象
        Dog d = new Dog("yangyang",12);
        System.out.println(d.getName() + "," + d.getAge());
        d.drink();
        d.eat();
    }
}

抽象类和抽象方法的意义： 疑问： 把子类中共性的内容抽取到父类之后，由于方法体不确定，需要定义为抽象，子类使用时需要重写，那么我不抽取到父类，直接在子类写不是更节约代码吗？

强制子类按照统一的格式进行书写。