Java学习日记-13

芝士顶针

已于 2022-10-22 20:02:45 修改

阅读量141

点赞数 1

文章标签： java 学习 servlet

于 2022-10-22 16:50:24 首次发布

本文链接：https://blog.csdn.net/a1245673676/article/details/127423099

版权

面向对象的特征一：封装与隐藏
一、问题的引入：
   当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作
   要受到属性的数据类型和存储范围的制约。除此之外，没有其他制约条件。但是，在实际问题当中，我们往
   往需要给属性赋值加入额外的限制条件。这个条件不能在属性声明时候体现，我们只能通过方法进行限制条件
   的添加。（比如：setLegs）同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要讲
   属性声明为私用的（private）
   - ->此时针对属性就是封装性）
二、封装性的体现。
我们将类的属性xxx私有化（private），同时，提供公共的（public）方法来获取（getXxx）和设置（setXxx）该属性的值
扩展：封装性的体现：①如上 ② 不对外暴露的私有方法 ③ 单例模式

三、封装性的体现，需要权限修饰符来配合
1.Java规定的4种权限（从小到大排序）：private、缺省、protected、public

面向对象的特征之二，继承性

一、继承性的好处
①减少了代码的冗余，提高代码的复用性
②便利了功能的扩展
③为之后的多态性的使用，提供了前提

二、继承性的格式：class A extends B{}
* A:子类、派生类、subclass
* B:父类、超类、superclass
* 2.1体现：一旦子类A继承父类B之后，子类A就能从父类B中获取结构：属性、方法
* 特别的：父类中声明为private的属性或方法，子类继承父类以后，任然认为获取了分类中私有的结构。
* 只是因为封装性的影响，使得子类不能直接调用父类的结构而已。
* 2.2子类继承父类以后，还可以声明自己特有的属性或方法，实现功能的扩展。
* 子类和父类的关系，不同于子集和集合的关系。

三、java中关于继承性的规定：
* 1.一个类可以被多个子类继承。
* 2.java中类的单继承性：一个类只能有一个父类。
* 3.子父类是一个相对的概念。
* 4.子类直接继承的父类，称为直接父类。间接继承的父类称为：间接父类
* 5.子类继承父类以后，就获取了直接父类以及间接父类中声明的属性和方法

四、如果我们没有显示的声明一个类的父类的话，则此类就继承java.lang.Object类
* 所有的java类(除java.lang.Object类之外)都直接或间接的继承与java.lang.Object类。
* 意味着，所有的类都具有java.lang.Object类声明的功能。

方法重载：
1.定义：在同一个类中有同名的方法，只要参数个数或者参数类型不一样则允许重载。
两同一不同：同一个类同一个方法名，参数不同

2.举例：
Arrays类中重载的sort() / binarySearch()

3.判断是否重载：
跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！

4.在通过对象调用方法时，如果确定某一个指定的方法；
方法名 ----> 参数列表

方法重写：(override / overwrite)
1.子类对父类进行继承，可以对父类同名同参数的方法进行重写，进行覆盖。
2.应用：重写以后，当子类通过子类对象对父类同名同参的方法进行调用时候，则会调用重写的那一个方法。
3.重写的规定：
       方法的声明：权限修饰符返回值类型方法名(形参列表) throws 异常类型 {
                       //方法体
                               }
       俗称：子类中叫重写方法，父类中叫被重写方法
①子类重写的方法的方法名和形参列表与父类被重写的方法名形参列表相同
②子类重写的方法权限修饰符不小于父类被重写的方法权限修饰符
>特殊：子类不能重写父类中声明为private的方法
③返回值类型
   >父类中被重写的方法返回值类型是void，子类重写的方法也只能是void
> 父类被重写的方法返回值类型是A类型。则子类中重写的方法返回值类型可以是A类，也可以是A类的子类
   > 父类被重写的方法返回值类型是基本数据类型，则子类中重写的方法的返回值也必须是基本数据类型
④ 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型

子类和父类中同名同参数的方法要么都声明为非static的（考虑重写），要么都声明为static的（不是重写）

super关键字
1.super可以理解为父类的（如同this理解为当前类的）
2.super可以用属性，方法，构造器
3.super的使用调用属性
3.1 我们可以在子类的方法或构造器中。通过使用“super.属性“或”super.方法“的方式，显示的调用父类中
声明的属性或者方法。但是，通常情况下，我们习惯省略“super“。
3.2 特殊情况，当子类中出现和父类同名的属性或者方法。我们想在子类中调用与父类同名的属性或者方法。需要使用super关键字
3.3 特殊情况，当子类重写了父类中的方法以后，我们想在子类中调用父类中被重写的方法，则必须显示的使用super.方法调用父类中
被重写的方法。
4.super调用构造器
4.1 我们在子类的构造器中显示的使用“super(形参列表)”的方式，调用父类中声明的指定的构造器
4.2 “super(形参列表)”的使用，必须声明在子类的构造器首行！
4.3 我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能二选一，不能同时出现
4.4 当我们在子类的构造器首行，没有显示的声明"this(参数列表)或"super(形参列表)"，则默认调用的是父类中的空参的构造器：super()
4.5 在类的多个构造器中，至少有一个类的构造器使用了"super(形参列表)"，调用父类的构造器

子类对象实例化的全过程

1.从结果上来看：（继承性）
子类继承父类以后，就获取了父类中声明的属性或方法。
创建子类的对象，在堆空间中，就会加载所有父类中声明的属性。
米
2.从过程上来看：
当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的父类的构造器
直到调用了java.lang.Object类中空参的构造器为止。正因为加载过所有的父类的结构，所以才可以看到内存中有
父类中的结构，子类对象才可以考虑进行调用。

提示：虽然调用了多个构造器，但是自始至终只创建了一个对象

面向对象特征之三：多态性
1.理解多态性：可以理解为一个事物的多种形态
2.何为多态性：
对象的多态性：分类的引用指向子类的对象（或子类的对象赋给父类的引用）
3.多态的使用：虚拟机方法调用
有了对象的多态性之后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类中重写父类的方法
总结：编译，看左边；运行，看右边。
4.多态的使用前提：
4.1有类的继承关系
4.2子类对父类中的方法进行重写

package Bzhan.polymorphicP280;/*
 * @Description:多态性的使用
 * @Author:clh
 * @Date:2022/10/22
 * @VERSION:1.8
 */

public class AnimalTest {
    public static void main(String[] args) {
        AnimalTest test = new AnimalTest();
        test.func(new Dog());
        test.func(new Cat());
    }
    public void func(Animal animal){
        animal.eat();
        animal.shout();
    }
}

class Animal{

    public void eat(){
        System.out.println("吃");
    }
    public void shout(){
        System.out.println("叫");
    }


}
class Dog extends Animal{
    public void eat(){
        System.out.println("狗吃肉");
    }
    public void shout(){
        System.out.println("汪汪汪！");
    }
}
class Cat extends Animal{
    public void eat(){
        System.out.println("猫吃鱼");
    }
    public void shout(){
        System.out.println("喵喵喵！");
    }
}