Java基础-抽象类,代码块内容概述

抽象类的概述

1.当我们在做子类共性功能抽取时,有些方法在父类中没有具体的体现,这个时候就需要使用抽象类了!
2.在Java中,一个没有方法体的方法应该定义为抽象方法,而类中如果有抽象方法的话中,该类必须定义为抽象类中!
3.简单说 抽象类中可以没有抽象方法,但是抽象方法必须定义在抽象类中

抽象类的特点

• 抽象类和抽象方法必须使用abstract 关键字修饰

//抽象类的定义
public abstract class 类名 {}

//抽象方法的定义
public abstract void eat();

• 抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类
• 抽象类不能实例化
• 抽象类中可以有构造方法
• 抽象类的子类
  要么重写抽象类的所有的方法
  要么是抽象类

抽象类的案例(仅供参考)

• 案例需求

  ​ 定义猫类(Cat)和狗类(Dog)

  ​ 猫类成员方法：eat（猫吃鱼）drink（喝水…）

  ​ 狗类成员方法：eat（狗吃肉）drink（喝水…）

• 实现步骤

  1. 猫类和狗类中存在共性内容，应向上抽取出一个动物类（Animal）
  2. 父类Animal中，无法将 eat 方法具体实现描述清楚，所以定义为抽象方法
  3. 抽象方法需要存活在抽象类中，将Animal定义为抽象类
  4. 让 Cat 和 Dog 分别继承 Animal，重写eat方法
  5. 测试类中创建 Cat 和 Dog 对象，调用方法测试

• 代码实现

  • 动物类

public abstract class Animal {
    public void drink(){
        System.out.println("喝水");
    }

    public Animal(){

    }

    public abstract void eat();
}

• 猫类

 -  `public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}`

• 狗类

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }
}

• 测试类

public static void main(String[] args) {
        Dog d = new Dog();
        d.eat();
        d.drink();

        Cat c = new Cat();
        c.drink();
        c.eat();

        //Animal a = new Animal();
        //a.eat();
    }

final 关键字的使用

• final关键字的作用
  final 代表最终的意思,可以修饰成员方法,成员变量,类

• final修饰类,方法,变量的效果
  final修饰的类:不可以被继承
  final修的的方法:不可以被重写
  final修的变量: 表明该变量是一个常量,不可以进行二次赋值
  变量是基本类型,不能改变的是值
  变量是引用类型,不能改变的是地址值,但是地址中的内容可以改变

• 代码示例

public static void main(String[] args){
    final Student s = new Student(23);
  	s = new Student(24);  // 错误
 	s.setAge(24);  // 正确
}

代码块

• 代码块的概述
  在Java中,使用{ }括起来的代码被称为代码块

• 代码块的分类
  局部代码块
  在方法中定义,限定变量的什么周期,及早释放,提高内存的利用率

• 代码示例

public class Test {
    /*
        局部代码块
            位置：方法中定义
            作用：限定变量的生命周期，及早释放，提高内存利用率
     */
    public static void main(String[] args) {
        {
            int a = 10;
            System.out.println(a);
        }

       // System.out.println(a);
    }
}

构造代码块

• 位置: 类中方法外定义
• 特点: 每次构造方法执行的时，都会执行该代码块中的代码，并且在构造方法执行前执行
• 作用: 将多个构造方法中相同的代码，抽取到构造代码块中，提高代码的复用性
• 代码示例

public class Test {
    /*
        构造代码块:
            位置：类中方法外定义
            特点：每次构造方法执行的时，都会执行该代码块中的代码，并且在构造方法执行前执行
            作用：将多个构造方法中相同的代码，抽取到构造代码块中，提高代码的复用性
     */
    public static void main(String[] args) {
        Student stu1 = new Student();
        Student stu2 = new Student(10);
    }
}

class Student {

    {
        System.out.println("好好学习");
    }

    public Student(){
        System.out.println("空参数构造方法");
    }

    public Student(int a){
        System.out.println("带参数构造方法...........");
    }
}

静态代码块

• 位置: 类中方法外定义
• 特点: 需要通过static关键字修饰，随着类的加载而加载，并且只执行一次
• 作用: 在类加载的时候做一些数据初始化的操作
• 示例代码

public class Test {
    /*
        静态代码块:
            位置：类中方法外定义
            特点：需要通过static关键字修饰，随着类的加载而加载，并且只执行一次
            作用：在类加载的时候做一些数据初始化的操作
     */
    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person(10);
    }
}

class Person {
    static {
        System.out.println("我是静态代码块, 我执行了");
    }

    public Person(){
        System.out.println("我是Person类的空参数构造方法");
    }

    public Person(int a){
        System.out.println("我是Person类的带...........参数构造方法");
    }
}