第二章面向对象高阶（1）

还是要学习才行

已于 2022-06-29 21:38:34 修改

阅读量177

点赞数 1

分类专栏： Java学习笔记文章标签： java jvm 开发语言

于 2022-06-28 17:32:47 首次发布

本文链接：https://blog.csdn.net/weixin_43273246/article/details/125504538

版权

Java学习笔记专栏收录该内容

18 篇文章 1 订阅

订阅专栏

第二章面向对象高阶–分包与继承

文章目录

第二章面向对象高阶--分包与继承
前言
一、分包分类思想
二、static关键字
三、继承
四、代码块
- 4.1代码块概述 (理解)
- 4.2代码块分类 (理解)

前言

学习笔记

一、分包分类思想

1.1分类思想概述 (理解)

分工协作,专人干专事

1.2分包思想概述 (理解)

如果将所有的类文件都放在同一个包下,不利于管理和后期维护,所以,对于不同功能的类文件,可以放在不同的包下进行管理

1.3包的概述 (记忆)

包：本质上就是文件夹
创建包：多级包之间使用 " . " 进行分割多级包的定义规范：公司的网站地址翻转(去掉www) 比如：csdn的网站址为https://www.csdn.net/ 后期我们所定义的包的结构就是：net.csdn.其他的包名
包的命名规则：字母都是小写

1.4包的注意事项 (理解)

package语句必须是程序的第一条可执行的代码
package语句在一个java文件中只能有一个
如果没有package,默认表示无包名

1.5类与类之间的访问 (理解)

同一个包下的访问

不需要导包，直接使用即可

不同包下的访问

import 导包后访问
通过全类名（包名 + 类名）访问

注意：import 、package 、class 三个关键字的摆放位置存在顺序关系

package 必须是程序的第一条可执行的代码
import 需要写在 package 下面
class 需要在 import 下面

二、static关键字

2.1static关键字概述 (理解)

static 关键字是静态的意思,是Java中的一个修饰符,可以修饰成员方法,成员变量

2.2static修饰的特点 (记忆)

被类的所有对象共享
是我们判断是否使用静态关键字的条件
随着类的加载而加载，优先于对象存在
对象需要类被加载后，才能创建
可以通过类名调用
也可以通过对象名调用

2.3static关键字注意事项 (理解)

静态方法只能访问静态的成员
非静态方法可以访问静态的成员，也可以访问非静态的成员
静态方法中是没有this关键字

示例代码

Student类

package com.test;

public class Student {
    String name;
    int age;
    static String school;

    /*
        静态随着类的加载而加载, 优先于对象存在
        非静态需要在创建对象之后,才可以进行使用

        1. 静态方法中, 只能访问静态成员(成员变量, 成员方法)
        2. 非静态方法中, 可以使用静态成员, 也可以使用非静态成员
        3. 静态方法中, 没有this关键字
     */
    public void show() {
        System.out.println(name + "..." + age + "..." + school);
    }

    public static void method(){
        // this: 当前对象的引用
        // this需要在创建对象之后, 才会存在, 静态存在的时候, 对象可能还没有被创建
        // this.name = "张三";
        System.out.println(school);
    }
}

测试类

package com.test;

public class Test1Static {
    /*
        1. 被static修饰的成员, 会被该类的所有对象所[共享]
        2. 被static修饰的成员, 会随着类的加载而加载, 优先于对象存在
        3. 多了一种调用方式, 可以通过类名.进行调用
     */
    public static void main(String[] args) {
        Student.school = "xx大学";
        Student stu1 = new Student();
        stu1.name = "张三";
        stu1.age = 23;
        //stu1.school = "xx大学";
        stu1.show();

        Student stu2 = new Student();
        stu2.show();

        //调用静态方法
        Student.method();
    }
}

三、继承

3.1 继承的基本概念

3.1.1继承的实现（掌握）

继承的概念
- 继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法
实现继承的格式
- 继承通过extends实现
- 格式：class 子类 extends 父类 { }
  - 举例：class Dog extends Animal { }
继承带来的好处
- 继承可以让类与类之间产生关系，子父类关系，产生子父类后，子类则可以使用父类中非私有的成员。
示例代码

public class Fu {
    public void show() {
        System.out.println("show方法被调用");
    }
}
public class Zi extends Fu {
    public void method() {
        System.out.println("method方法被调用");
    }
}
public class Demo {
    public static void main(String[] args) {
        //创建对象，调用方法
        Fu f = new Fu();
        f.show();

        Zi z = new Zi();
        z.method();
        z.show();
    }
}

3.1.2 继承的好处和弊端（理解）

继承好处
- 提高了代码的复用性(多个类相同的成员可以放到同一个类中)
- 提高了代码的维护性(如果方法的代码需要修改，修改一处即可)
继承弊端
- 继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性
继承的应用场景：
- 使用继承，需要考虑类与类之间是否存在is…a的关系，不能盲目使用继承
  - is…a的关系：谁是谁的一种，例如：老师和学生是人的一种，那人就是父类，学生和老师就是子类

3.1.3 Java中继承的特点（掌握）

Java中继承的特点
1. Java中类只支持单继承，不支持多继承
  - 错误范例：class A extends B, C { }
2. Java中类支持多层继承

多层继承示例代码：

public class Granddad {

    public void drink() {
        System.out.println("爷爷爱喝酒");
    }

}

public class Father extends Granddad {

    public void smoke() {
        System.out.println("爸爸爱抽烟");
    }

}

public class Mother {

    public void dance() {
        System.out.println("妈妈爱跳舞");
    }

}
public class Son extends Father {
	// 此时，Son类中就同时拥有drink方法以及smoke方法
}

3.2 继承中的成员访问特点

3.2.1 继承中变量的访问特点（掌握）

在子类方法中访问一个变量，采用的是就近原则。

子类局部范围找
子类成员范围找
父类成员范围找
如果都没有就报错(不考虑父亲的父亲…)

示例代码

class Fu {
    int num = 10;
}
class Zi {
    int num = 20;
    public void show(){
        int num = 30;
        System.out.println(num);
    }
}
public class Demo1 {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();	// 输出show方法中的局部变量30
    }
}

3.2.2 this&super（掌握）

this&super关键字：
- this：代表本类对象的引用
- super：代表父类存储空间的标识(可以理解为父类对象引用)
this和super的使用分别
- 成员变量：
  - this.成员变量 - 访问本类成员变量
  - super.成员变量 - 访问父类成员变量
- 成员方法：
  - this.成员方法 - 访问本类成员方法
  - super.成员方法 - 访问父类成员方法
构造方法：
- this(…) - 访问本类构造方法
- super(…) - 访问父类构造方法

问题：如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢？

1. 通过使用super关键字去显示的调用父类的带参构造方法
2. 子类通过this去调用本类的其他构造方法,本类其他构造方法再通过super去手动调用父类的带参的构造方法

注意: this(…)super(…) 必须放在构造方法的第一行有效语句，并且二者不能共存

3.2.3 继承中成员方法的访问特点（掌握）

通过子类对象访问一个方法

子类成员范围找
父类成员范围找
如果都没有就报错(不考虑父亲的父亲…)

3.2.4 方法重写（掌握）

1、方法重写概念
- 子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）
2、方法重写的应用场景
- 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容
3、Override注解
- 用来检测当前的方法，是否是重写的方法，起到【校验】的作用

3.2.5 方法重写的注意事项（掌握）

方法重写的注意事项

私有方法不能被重写(父类私有成员子类是不能继承的)
子类方法访问权限不能更低(public > 默认 > 私有)
静态方法不能被重写,如果子类也有相同的方法,并不是重写的父类的方法

示例代码

public class Fu {
    private void show() {
        System.out.println("Fu中show()方法被调用");
    }

    void method() {
        System.out.println("Fu中method()方法被调用");
    }
}

public class Zi extends Fu {

    /* 编译【出错】，子类不能重写父类私有的方法*/
    @Override
    private void show() {
        System.out.println("Zi中show()方法被调用");
    }
   
    /* 编译【出错】，子类重写父类方法的时候，访问权限需要大于等于父类 */
    @Override
    private void method() {
        System.out.println("Zi中method()方法被调用");
    }

    /* 编译【通过】，子类重写父类方法的时候，访问权限需要大于等于父类 */
    @Override
    public void method() {
        System.out.println("Zi中method()方法被调用");
    }
}

3.2.6 权限修饰符 (理解)

权限修饰符

3.2.7 继承中构造方法的访问特点（理解）

注意：子类中所有的构造方法默认都会访问父类中无参的构造方法

子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化，原因在于，每一个子类构造方法的第一条语句默认都是：super()

3.2.8 super内存图（理解）

对象在堆内存中，会单独存在一块super区域，用来存放父类的数据

3.3 抽象类

3.3.1抽象类的概述（理解）

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

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

3.3.2抽象类的特点（记忆）

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

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

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

抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
抽象类不能实例化
抽象类可以有构造方法
抽象类的子类

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

要么是抽象类

3.3.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();
    }

3.3.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();
    }
}

3.3.5final（应用）

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);  // 正确
}
```

四、代码块

4.1代码块概述 (理解)

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

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

还是要学习才行

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
第二章面向对象高阶（1）

学习笔记分工协作,专人干专事如果将所有的类文件都放在同一个包下,不利于管理和后期维护,所以,对于不同功能的类文件,可以放在不同的包下进行管理包：本质上就是文件夹创建包：多级包之间使用 " . " 进行分割多级包的定义规范：公司的网站地址翻转(去掉www) 比如：csdn的网站址为https://www.csdn.net/ 后期我们所定义的包的结构就是：net.csdn.其他的包名包的命名规则：字母都是小写package语句必须是程序的第一条可执行的代码package语句在一个java文件中只能有一个
复制链接

扫一扫