0
点赞
收藏
分享

微信扫一扫

Java知识【抽象类&代码块】


目录

​​1,抽象类​​

​​1.1:抽象类的概述(理解)​​

​​1.2:抽象类的特点(记忆)​​

​​1.3:抽象类的案例(应用)​​

​​1.4:模板设计模式​​

​​1.5:final(应用)​​

​​2,代码块​​

​​2.1:代码块概述(理解)​​

​​2.2:代码块分类(理解)​​

1,抽象类

1.1:抽象类的概述(理解)

当我们在做子类共性功能抽取时,有些方法在父类中并没有具体的体现,这个时候就需要抽象类了!

在Java中,一个没有方法体的方法应该定义为抽象方法,而类中如果有抽象方法,该类必须定义为抽象类!

1.2:抽象类的特点(记忆)

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

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

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

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

1.3:抽象类的案例(应用)

  • 案例需求
    定义猫类(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();
}

1.4:模板设计模式

  • 设计模式
    设计模式(Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。 使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。
  • 模板设计模式
    把抽象类整体就可以看做成一个模板,模板中不能决定的东西定义成抽象方法 让使用模板的类(继承抽象类的类)去重写抽象方法实现需求
  • 模板设计模式的优势
    模板已经定义了通用结构,使用者只需要关心自己需要实现的功能即可
  • 示例代码
    模板类

/*
作文模板类
*/
public abstract class CompositionTemplate {

public final void write(){
System.out.println("<<我的爸爸>>");

body();

System.out.println("啊~ 这就是我的爸爸");

}

public abstract void body();
}

实现类A

public class Tom extends CompositionTemplate {

@Override
public void body() {
System.out.println("那是一个秋天, 风儿那么缠绵,记忆中, " +
"那天爸爸骑车接我放学回家,我的脚卡在了自行车链当中, 爸爸蹬不动,他就站起来蹬...");
}
}

实现类B

public class Tony extends CompositionTemplate {
@Override
public void body() {

}

/*public void write(){

}*/
}

测试类

public class Test {
public static void main(String[] args) {
Tom t = new Tom();
t.write();
}
}

1.5:final(应用)

  • fianl关键字的作用
  • final代表最终的意思,可以修饰成员方法,成员变量,类
  • final修饰类、方法、变量的效果
  • fianl修饰类:该类不能被继承(不能有子类,但是可以有父类)
  • final修饰方法:该方法不能被重写
  • final修饰变量:表明该变量是一个常量,不能再次赋值
  • 变量是基本类型,不能改变的是值
  • 变量是引用类型,不能改变的是地址值,但地址里面的内容是可以改变的
  • 举例

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

2,代码块

2.1:代码块概述(理解)

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

2.2:代码块分类(理解)

局部代码块

  • 位置: 方法中定义
  • 作用: 限定变量的生命周期,及早释放,提高内存利用率
  • 示例代码

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类的带...........参数构造方法");
}
}

举报

相关推荐

Java抽象类

JAVA——抽象类

java:抽象类

java 抽象类

java抽象类

抽象类基本知识

0 条评论