标签：重写 Java 语言继承子类学习抽象父类方法

JavaSE2

面向对象（OOP）编程

初始面向对象

面向过程 & 面向对象

面向过程思想
- 步骤清晰简单，第一步做什么，第二步做什么....
- 面向过程适合处理一些简单的问题
面向对象思想
- 物以类聚，分类的思维模式，思考问题是否首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
- 面向对象适合处理复杂的问题，适合处理需要多人协作的问题。
对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路，来分析整个系统。但是，具体到微观操作，仍然需要面向对象的思路去处理。

什么是面向对象

面向对象编程（Object-Oriented Programming, OOP）
面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。
抽象
三大特性：
- 封装
- 继承
- 多态
从认识论的角度考虑是现有对象后又类。对象，是具体的的事物。类是抽象的，是对对象的抽象
从代码运行的角度考虑是先有类后有对象。类的对象是模板。

方法回顾和加深

方法的定义
- 修饰符
- 返回值
- break 和 return的区别
  - break跳出循环
  - return结束方法
- 方法名
- 参数列表
- 异常抛出

方法的调用

静态方法（static关键字修饰）
- 带static关键字修饰的方法，会在类加载时一起加载。
非静态方法(没有static关键字修饰)
- 没有static修饰的方法，只有在类实例化之后才存在。
形参和实参

值传递和引用传递

值传递（pass by value）**是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。

引用传递（pass by reference）是指在调用函数时将实际参数的地址直接传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

方法的重载

//引用传递
public class Demo01 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);

        Demo01.change(person);
        System.out.println(person.name);

    }
    public static void change(Person person){
        person.name = "yuan";
    }
}
class Person{
    String name;
}
//结果 null
//yuan

//=============
//值传递
public class Demo02 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);

        changeInt(a);
        System.out.println(a);

    }
    public static void changeInt(int a){
        a = 10;
    }
}
//结果 1 1，变量a前后的值没有变

this关键字

对象的创建分析

类与对象的关系

类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。
- 动物、植物、手机、电脑........
- Person类、Pet类、Car类，这些类都是用来描述/定义某一类具体的事物应该具备的特点（属性）和行为（方法）
对象是抽象概念的具体实例
- 小明就是人的一个具体实例，小明家里的旺财就是狗的一个具体实例。
- 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。

创建与初始化对象

使用new关键字创建对象
使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认初始化以及对类中的构造器的调用。
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：
1. 必须和类的名字相同
2. 必须没有返回类型，也不能写void
构造器必须学会

构造器详解

构造器：

和类名相同
没有返回值

作用：

new 本质是在调用构造方法
初始化对象的值

注意点：

定义有参构造之后，如果想使用无参构造，显式的定义一个无参构造；当没有有参构造时，无参构造虽然没有显式（让我们看到）的表示出来，但是默认是有的，因为实例化类的时侯，能成功。

创建对象的内存分析：

面向对象的三大特性

封装
继承
多态

封装

该露的露，该藏的藏
- 我们程序设计要求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴漏少量的方法给外部使用。
- 封装（数据的隐藏）
  - 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
记住：属性私有，get/set

//当一个类中的属性为私有时，无法直接通过实例化类之后访问，而需要通过调用实例化类中的getter和setter方法来间接的访问或修改属性。

封装的作用
1. 提高代码的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 系统可维护性提高了

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
extends的意思是“扩展”。子类是父类的扩展。
JAVA类中只有单继承，没有多继承！（一个子类只能继承一个父类）
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
子类和父类之间，从意义上讲应该具有“is a”的关系。

IDEA中查看类与类之间的继承关系时，可以使用快捷键“Ctrl + H”

object类

在Java中，所有的类，都默认直接或者间接继承object类

super

  > //super属性
  > ![image-20230113161942420](C:\Users\lmyfi\AppData\Roaming\Typora\typora-user-images\image-20230113161942420.png)
  >
  > //super方法
  >
  > ![image-20230113162332624](C:\Users\lmyfi\AppData\Roaming\Typora\typora-user-images\image-20230113162332624.png)

super注意点：
1. 调用父类的构造方法时，super()必须要在子类构造器的第一行
1. super必须只能出现在子类的方法或者构造方法中
2. super和 this 不能同时调用构造方法！
super 与 this 区别：
1. 代表的对象不同：
  
  this：本身调用者这个对象
  
  super：代表父类对象的应用
2. 前提：
  
  this: 没有继承也可以使用
  
  super：只能在继承条件才可以使用
3. 构造方法：
  
  this() : 本类的构造
  
  super() : 父类的构造！

方法重写

//静态的方法

//静态的方法与非静态的方法区别很大！！！，
//下面这一张截图才是真正的重写，重写的方法时非静态的方法。

重写：需要继承关系，子类重写父类的方法！

方法名必须相同
参数列表必须相同
修饰符: 范围可以扩大，但不能缩小（比如：父类的方法修饰符为protected,子类重写时可以修改为public的修饰符，但不能修改比protected作用范围更小的修饰符）： public>protected>Default>private
抛出的异常：范围，可以被缩小，但不能被扩大。 ClassNotFoundExcetion --> Exception(大)

重写，子类的重写的方法必须与父类相同，方法体不同！

方法体：方法体包含具体的语句，定义该方法的功能。

方法为什么需要重写：

父类的功能，子类不一定需要，或者不一定满足！

多态

即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多。

多态存在的条件

有继承关系
子类重写父类方法
父类引用指向子类对象
对象能执行哪些方法，主要看对象左边的类型，和右边的关系不大

Student s1 = new Student();
Person s2 = new Student(); //指向子类
Object s3 = new Student();

//Student类继承了Person类，即Person类是Student类的父类
//假设父类中有eat方法，然后在子类重写了这一个方法
s1.eat(); //子类重写父类的方法，执行子类的方法
s2.eat(); //调用的是子类重写后的方法
//当子类Student中有父类Person没有的方法则父类就无法调用，如子类中由run方法
s1.run(); //可以调用
s2.run(); //报错，无法调用，因为父类中没有run的方法

注意：
1. 多态是方法的多态，属性没有多态性。
2. 父类和子类，有联系才能互相转换类型！ ClassCastException !
3. 存在的条件：继承关系，方法需要重写，父类引用指向子类对象！Father f1 = new Son();
4. 不能重写的方法
  1. static 方法，属于类，它不属于实例
  2. final 常量；
  3. private 方法；
instanceof. （类型转换）引用类型

抽象类和接口

抽象类

abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类。
抽象类型中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类
抽象类，不能使用new关键字来创建对象，它是用来让子类继承的
抽象方法，只有方法的声明，没有方法的实现，让是用来让子类实现的。

子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。

//抽象类    (java中类没有多继承，但接口可以多继承)
public abstract class Action {


    //抽象方法，只有方法名字，没有方法的实现！
    public abstract void doSomething();

    //1.不能使用new关键字来创建对象，它是用来让子类继承的
    //2.抽象类中可以写普通方法~
    //3.抽象方法必须在抽象类中~
    //抽象的抽象：约束

    public Action() {
    }
}

接口

声明类的关键字是class，声明接口的关键字是interface

普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有！
接口：只有规范！自己无法写方法~专业的约束！约束和实现分离：面向接口编程~
接口就是规范，定义的是一组规则，体现了现实世界中”如果你是...则必须能....“的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。
接口的本质是契约，就像我们人间的法律一样，制定好后大家都遵守。
OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如：c++、java、c#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象。

接口作用：

约束

定义一些方法，让不同的人实现

接口方法都是：public abstract + 数据类型 + 方法名（）

接口静态常量都是：public static final + 数据类型 +变量名

接口不能实例化_{，接口中没有构造方法}

implements可以实现多个多个接口

必须要重写接口中的方法~

内部类及OOP实战

内部类

内部类就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。

成员内部类
静态内部类
局部内部类
匿名内部类
lambada表达式

异常

异常体系结构

Java中把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类。
再Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception.

异常处理机制

抛出异常
捕获异常
异常处理五个关键字
- try、catch、finally、throw、throws

实际应用中的经验总结

处理运行异常时，采用逻辑去合理规避同时辅助try-catch处理
再多重catch块后面。可以加一个catch（Exception）来处理可能被遗忘的异常
对于不确定的代码，也可以加上try-catch，处理潜在的异常
尽量去处理异常，切忌只是简单地调用printStackTrack()去打印输出
尽量添加finally语句块去释放占用的资源

//IDEA快捷键

Ctrl + - 代码折叠

Ctrl + H 代码继承关系查看

Alt + insert 生成器（可以快速产生：构造器，get/set方法）

Alt + Enter 导包，修正代码。

Ctrl + D 复制当前行到下一行

Ctrl + Alt + T 快捷生成if/else或者try/catch

Ctrl + Alt + Shift + s 打开项目结构

标签：重写,Java,语言,继承,子类,学习,抽象,父类,方法
From： https://www.cnblogs.com/lmyfi/p/17510568.html

Java语言学习2