JavaSE进阶——Day01 继承、抽象类

发表于 更新于 分类于 阅读次数： Changyan： 本文字数： 985 阅读时长 ≈ 4 分钟

JavaSE进阶——Day01 该篇主要讲解Java中的继承、抽象类

学习目标

  • 面向对象回顾

  • 面向对象三大特征之一-继承

    • 继承的格式

    • Java继承的特点

    • Java继承中成员访问特点

  • 抽象类

    • 抽象类的格式

    • 抽象类的作用

    • 抽象类的注意事项

  • 设计模式-模板方式

1继承

1.1 为什么要学习继承 ?

1
2
1.当多个类有相同的属性和行为（非私有成员），为解决代码冗余, 提高代码复用性
2.继承用关键字'extends'

1.2 继承能解决什么问题 ?

1
2
3
1.多个类的共有的非私有属性和行为提炼到新的类中,提高代码复用性
2.建立类与类之间的关系(子与父)
3.解决代码冗余

1.3 继承中成员访问的特点 ?

1
2
3
4
1.单一继承（可多层）
2.就近访问（先访问本类成员，找不到再去找父类的）
3.只能访问父类中的非私有成员
4.可使用'super.成员'去访问父类成员，'this.成员'访问子类成员

1.4 方法重写与方法重载区别在于哪里 ?

方法重载:

1
2
1.发生在本类中, 方法名相同, 参数列表不同(类型,数量,顺序)
2.与返回值类型和权限修饰符无关(可相同可不同)

方法重写:
1
2
3
1.发生在继承关系中(父子类中),当子类与父类的方法一模一样的时候(参数列表和返回值),称为方法重写
2.子类重写的方法权限修饰符 >= 父类的
3.方法重写是为后面的多态做铺垫的

2. 抽象类

2.1 抽象类存在的意义 ?

1
2
3
4
5
1.当某个功能较为抽象, 对不类具体实现方式不一样时, 可以使用抽象方法来定义(无具体实现细节), 从而产生了抽象类作为父类
2.使用关键字'abstract'
Note:
1.抽象类中的抽象方法需要被子类重写
2.抽象类不能够实例化(仅仅是当创建子类对象时, 用来初始化父类)

2.2 抽象类使用注意事项 ?

3. 设计模式(难点)

3.1 什么是设计模式 , 设计模式有什么优势 ?

1
2
设计模式就是用来解决某个问题的方案
当开发中遇到一些常见问题时候,可以用设计模式实现

3.2 模板方法设计模式的作用 , 使用的方式 ?

1
2
规定好某个问题的整体框架和结构
把确定的内容提前写成具体方法, 把不确定的内容写成抽象方法让子类重写

笔记

面向对象三大特征：

  1. 封装
  2. 继承
  3. 多态

学习技巧：

继承

问题1：什么是继承

1
2
3
4
5
6
7
8
继承发生前提：当多个类中有相同的属性和行为时，把这些相同的属性和行为，抽取出来封装一个独立的类中

在Java中使用继承(extends)，来继承这些封装了公共属性和行为的类（父类）

继承：有父类、有子类


结论：让一个类(子类、派生类)继承另一个类(父类、超类、基类)

问题2：继承解决程序中的什么问题？

1
2
1、程序中代码的复用性（重复的代码抽取出来，封装到父类中，子类继承后就可以直接使用）
2、建立类和类之间的关系

问题3：继承怎么使用？ //写代码

1
2
3
4
5
6
7
public class 父类{
    //共性成员
}

public class 子类 extends 父类{
    //子类可以使用父类中定义的内容
}

问题4：继承在使用中有使用注意细节

1
2
3
4
5
6
7
8
1、Java只能单一继承(不能多继承)，允许多层次继承
2、在子类继承父类后，就直接可以父类中非私有的成员（成员变量、成员方法）
3、在继承中，访问成员变量或成员方法的原则：就近原则（先在子类中查找，子类没有再去父类中查找）
    super.父类中的成员变量
    super.父类中的成员方法
4、当父子类中存在一模一样的成员方法时，这种情况称为：方法重写
5、在继承中，要先初始化父类对象（ 通过子类构造方法中的super()来调用父类的无参构造 ）
   //调用父类有参构造方法： super(参数,....);

方法的体现：

  1. 重载

    • 在本类中发生
    • 方法名相同
    • 方法的参数列表不同（类型不同、数量不同、顺序不同）
    • 和返回值没有任何关系

  2. 重写

    • 发生在父子类(继承)中
    • 子类中的方法和父类的方法一模一样

方法重写：

  1. 什么是方法重写
  2. 方法重写解决什么问题
  3. 方法重写怎么实现
  4. 方法重写有什么注意细节

this关键字的使用：

1
2
3
4
5
6
7
8
9
10
11
12
13
//访问本类中的成员变量
this.成员变量名=数据值;

//访问本类中的成员方法
this.成员方法();

//访问本类中的构造方法（要求：只能使用某个构造方法，去调用本类中另一个构造方法）
public ClassName(){
    
}
public ClassName(String name){
    this(); //调用无参构造方法
}

学习套路：

  1. 这个技术是什么？
  2. 这个技术可以解决什么问题？ （重点）
  3. 这个技术怎么使用？ （重点）
  4. 这个技术在使用中的注意细节

回顾上午内容：

  • 继承

    • 继承是什么

      1
      2
      让一个类继承另一个类
      关键字：extends

    • 继承可以解决什么问题

      1
      2
      1、建立类与类之间的关系：父子关系
      2、可以解决程序中代码的复用性（子类可以直接使用父类中的非私有成员）

    • 继承怎么使用

      1
      2
      3
      4
      5
      6
      public class 父类{
          //成员
      }
      public class 子类 extends 父类{
          //子类可以直接使用父类中的非私有成员
      }

    • 继承在使用中的注意细节

      1
      2
      3
      4
      5
      6
      7
      8
      9
      1、Java语言只支持单一继承(不能多继承) ， 允许多层次继承
      2、子类不能继承父类中的私有成员
      3、当子类和父类中存在相同的成员时，访问原则：就近原则
         super.成员变量 
         super.成员方法()
         super()
         super(参数, ...) 
      4、子类对象在实例化完成之前，必须先初始化父类对象（只有父类初始化完成后子类才可以访问父类成员）
         //子类构造方法在执行时，有隐藏代码：super()  //默认调用父类中的无参构造方法

  • 方法重写

    • 什么是方法重写

      1
      当父子类中存在一模一样的非私有成员方法时，就可以称为：子类重写父类的方法（方法重写）

    • 方法重写可以解决什么问题

      1
      2
      3
      4
      5
      当父类中的方法，子类在调用时无法满足子类的要求，就可以在子类中重写父类的方法

      目的：
      1. 为后面学习多态准备
      2. 不愿意在起一个方法名

    • 方法重写怎么使用

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      public class 父类{
          public void show(String name){
              ....
          }
      }

      public class 子类 extends 父类{
          //重写方法
          @Override
          public void show(String name){
              //重新编写方法体业务代码
          }
      }

    • 方法重写的注意细节

      1
      2
      1、针对父类中私有方法不能重写
      2、必须和父类中的方法一模一样

JVM内存划分：

  1. 栈 //方法运行在栈内存中
  2. 堆 //对象存储于堆内存中
  3. 方法区 //存放加载的.class文件 //方法区有由N多个不同功能的小区域组成
  4. 寄存器
  5. 本地方法区

this：当前类对象引用

1
2
3
4
this.成员方法()
this.成员变量 = 数据值
this() //本类无参构造方法
this("字符串")//本类带有String类型参数的构造方法

super：父类对象引用

1
2
3
4
super.成员方法()
super.成员变量 = 数据值
super() //父类无参构造方法
super("字符串")//父类带有String类型参数的构造方法   
1
2
3
4
5
6
//父类：动物类
public abstract class Animal{
    //抽象方法：必须使用关键字abstract修饰
    //抽象方法：必须书写在抽象类中
    public abstract void eat();//在java语言中没有方法体的方法，称为：抽象方法 
}

普通类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class 类名{
    //成员变量
    private String name;
    
    //成员方法
    public void setName(String name){
        this.name = name;
    }
    
    //构造方法
    public 类名{
        
    }
}

抽象类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class 类名{
    //成员变量
    private String name;
    
    //成员方法
    public void setName(String name){
        this.name = name;
    }
    
    //构造方法
    public 类名{
        
    }
    
    //抽象方法
    public abstract void 抽象方法();
}
  • 抽象类，不能实例化（不能创建对象）
    • 疑问：既然不能创建对象了，为什么还要有构造方法？
      • 抽象类通常是用于父类，创建子类对象时，需要先初始化父类（抽象方法中构造方法的作用就是用于父类初始化使用）
  • 抽象类中的抽象方法，必须由子类重写

什么是设计模式？

  • 设计模式，就是一种解决方案（解决开发中某个问题的方案）

设计模式解决什么问题？

  • 在开发中一些常见问题，可以使用设计模式解决

模板设计模式：

  • 模板：就一个固定的格式
  • 模板设计：把确定的内容，提前准备好，把不确定的内容，定义为抽象方法（由子类重写）

创建对象：

1
2
3
Student stu = new Student(); //有名字的对象

//对象名： stu

匿名对象：

  • 没有名字的对象
1
2
new Student(); //创建的对象没有名字
new Student("张三",23);