【Java】韩顺平Java学习日志06——面向对象编程中级部分

IDEA快捷键

自定义：Settings——Keymap
1.ctrl+B——关键词定位方法
2.ctrl+H——查看类的层级关系
3.alt+insert——生成构造器
4.ctrl+/——注释与删除注释
5.new语句.var——自动分配变量名
6.psvm或main——快速生成main类语句
7.sout——快速生成输出语句
8.fori——for循环

包

包的作用

1.区分相同名字的类
2.当类很多是，可以很好的管理类（JavaAPI文档）
3.控制访问范围

基本语法

package com.包名;
package 关键字，表示打包
com.包名 表示包名

包的本质就是创建不同的文件夹来保存类文件
示例：

package com.use;

import com.xiaoqiang.Dog;

public class Test {
    public static void main(String[] args) {
        Dog dog=new Dog();
        System.out.println(dog);
        com.xiaoming.Dog dog1=new com.xiaoming.Dog(); 
    }
}

命名

命名规则

只能包含数字，字母，下划线，小圆点，但不能数字开头，不能是关键字或保留字

命名规范

一般是小写字母+小圆点
com.公司名.项目名.业务模块名

常用的包

java.lang.* lang包是基本包，默认引入，不需要再引入
java.util.* util包系统提供的工具包，工具类，使用Scanner
java.net.* 网络包，网络开发
java.awt.*是做Java界面开发GUI

引入包

语法：import 包
引入包主要是使用该包下面的类
可以只引入某个包下面的一个类，也可以引入某个包下面所有的类
例如：import java.util.Scanner 和 import java.util.*

使用细节

1.package的作用是声明当前类所在的包，需要放在类的最上面，一个类中最多只有语句package
2.import指令，位置放在package的下面，再类定义前面，可以有多句且没有顺序

访问修饰符

Java员工有四种访问控制修饰符，用于控制方法和属性的访问权限（范围）
1.公开级别：public 对外公开
2.受保护级别：protected 对子类和同一个包中的类公开
3.默认级别：没有修饰符号，向同一个包中的类公开
4.私有级别：private 只有类本身可以访问，不对外公开

注意

1.修饰符可以用来修饰类以及类中的属性，成员方法
2.只有默认的和public才可以修饰类
3.成员方法的访问规则和属性完全一样

封装

封装就是把抽象出的数据【属性】和对数据操作【方法】封装在一起，数据被保护在内部，程序的其他部分只有通过授权的操作【方法】，才能对数据进行操作

好处

1.油藏实现细节，方法
2.可以对数据进行验证，保证安全合理

实现步骤

1.将属性私有化（不能直接修改属性）
2.提供一个公共的set方法，用于对属性判断并赋值（加入数据验证的业务逻辑）

public void setXXX（类型，参数名）{
//加入数据验证的业务逻辑
属性=参数名；
}

3.提供哦那个一个公共的get方法，用于获取属性的值

public 数据类型 getXXX（）{
//权限判断
return XX；
}

将setXXX方法余构造器结合，同时完成赋值和业务逻辑验证

    public Bag(String name, int age, int score) {
//        this.name = name;
//        this.age = age;
//        this.score = score;
        this.setName(name);
        this.setAge(age);
        this.setScore(score);
    }

具有保护机制

继承

基本介绍和示意图

继承可以解决代码复用，当多个类存在相同的属性（变量）和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends来声明继承父类

基本语法

class 子类 extends 父类{
}

1.子类就会自动拥有父类定义的属性和方法
2.父类又叫基类，超类
3.子类又叫派生类

好处

1.代码的复用性提高
2.代码的扩展性和维护性提高

使用细节

1.子类继承了所有的属性和方法，非私有的属性和方法可以在子类直接访问，但是私有属性和方法不能在子类直接访问，要通过父类提供的公共的方法去访问
2.子类必须调用父类的构造器，完成父类的初始化（有时会默认调用）
3.当创建子类对象时，不管使用哪个构造器，默认情况下总会去调用父类的无参构造器，
如果父类没有提供无参构造器，则必须在子类的构造器中使用super去指向使用父类的哪个构造器完成对父类的初始化工作，否则编译不会通过
4.如果希望指定去调用父类的某个构造器，则显式的调用一下：super（参数列表）
5.super在使用时，需要放在构造器的第一行，先构造父类，再构造子类，suoer只能再构造器中使用
6.super（），this（）都只能放在构造器的第一行，因此，这两个放啊不能共存在一个构造器
7.Java所有类都是Object的子类，Object类是所有类的基类
8.父类构造器的掉哟给不限于直接父类，将一直往上追溯直到Object类（顶级父类）
9.子类最多只能继承一个父类（直接继承），Java中是单继承机制
10.不能滥用继承，子类和父类之间必须满足is-a的逻辑关系

本质

继承的内存布局

按照查找关系返回信息
1.首先查看子类是否有该属性
2.如果子类有这个属性，并且可以访问，则返回信息
3.如果子类没有这个属性。就看父类有没有这个属性（如果父类有该属性，并且可以访问，就返回信息）
4.如果父类没有就继续赵上一级父类，直到Object

实例

注意默认调用父类的无参构造器


继承的核心，父类完成父类属性的构造初始化，子类完成子类属性的构造初始化

super关键字

super代表父类的引用，用于访问父类的属性，方法，构造器

基本语法

1.访问父类的属性，单不能访问父类的private属性：super.属性
2.访问父类的方法，但不能访问父类发private方法：super.方法
3.访问父类的构造器：super（参数列表）；只能放在构造器的第一句，只能出现那一句，只能再构造器中调用，不能与this语句同时使用

使用细节

1.调用父类构造器的好处：分工明确，父类的属性由父类初始化，子类的属性由子类初始化
2.当子类中有和父类中的成员重名时，未来访问父类的成员，必须通过super，如果没有重名，使用super，this，直接访问都是一样的
3.super的访问不限于直接父类，如果爷爷类和奔雷中有同名的成员，有可以用super去访问爷爷类的成员，如果多个基类中都有同名的成员，使用super访问遵循就近原则

cal();
this.cal();
super.cal();//该方法直接跳过本子类，查找父类，其他规则一样

访问方法：
1.先找本类，如果有，则调用
2.如果没有则找父类（如果有，并且可以调用，则调用）
3.如果父类没有，则继续找父类的父类，直到Object类
4.如果查找过程中，找到了，但是不能访问，则报错（即使后面的父类中存在可以访问的该同名属性）
5.如果查找过程中，没有找到，则提示方法不存在
属性的访问同理

super与this的比较

方法重写/覆盖

方法覆盖就是子类有一个方法和父类的莫格方法的名称，返回类，参数一模一样，我们就说子类的中国方法覆盖率父类的方法

需要满足的条件

1.子类的方法的参数，方法名称，要和父类方法的参数，方法名称玩去哪一样
2.子类方法的返回类型和父类方法的返回类型一样，或者是父类返回类型的子类，比如：父类的返回类型是Object，子类方法的返回类型但是String
3.子类方法不能缩小父类方法的访问权限

方法重写和方法重载的区别

多态

多态：提高代码的复用性，而且有利于代码的维护

基本介绍

方法或对象具有多种形态，是面向对象的第三大特征，堕胎是是建立在封装和继承基础上的

具体体现

1.方法的多态
重写和重载就体现多态
重载：通过传入不同的参数调用同名的不同的方法，对于该方法来说就是多种状态的体现
重写：根据不同的对象调用同名的不同的方法，对于该方法来说就是多种状态的体现

2.对象的多态
一个对象的编译类型和运行类型可以不一致{父类的引用可以指向子类的对象）
编译类型在定义对象时就确定了，不能改变
运行类型是可以变化的
编译类型看定义时=号的左边，运行类型看=号的右边

public class Main {
    public static void main(String[] args) {
        Animal animal=new Dog();//animal的编译类型是Animal，运行类型是Dog
        animal.cry();//dog
        animal=new Cat();//animal的运行类型变成了的Cat，编译类型仍然是Animal
        animal.cry();//cat

    }
}

public class Master {
    String name;

    public Master(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public void feed(Animal animal,Food food)
    //animal可以指向animal的子类对象
    //food可以指向food的子类对象
    {
        System.out.println(name);
    }
}

使用细节

多态的前提是：两个对象（类）存在继承关系

多态的向上转型

1.本质： 父类引用指向了子类的对象
2.语法：父类类型 引用名=new 子类类型（）
3.特点：编译类型看左边，运行类型看右边

可以调用父类中的所有成员（需要遵守访问权限）
不能调用子类中的特有成员（因为在编译阶段，能调用哪些成员，是由编译类型决定的
最终运行效果看子类的具体实现，运行是关心运行类型，不关心编译类型
调用运行的方法遵循就近原则，先从运行时的子类类型开始查找，未能找到时逐级向父类递增

class Cat extends Animal
Animal animal=new Cat()

多态的向下转型

1.语法：子类类型 引用名=（子类类型）父类引用
2.只能强转父类的引用，不能强转父类的对象
3.要求父类的引用必须指向的是当前目标类型的对象
4.当向下转型后，可以调用子类类型中的所有成员

Cat cat =（Cat)animal;

属性没有重写之说，访问时看编译类型

instanceOf为比较操作符，用于判断对象的（运行）类型是否为XX类型或XX类型的子类型

注意：此处判断的是运行类型是否为后面的类型或子类型，而不是编译类型

Java的动态绑定机制

1.当调用对象方法的时候，该方法会对该对象的内存地址/运行类型进行绑定
2.当调用对象属性时，没有动态绑定机制，哪里声明，哪里使用

多态应用

多态数组

数组的定义类型为父类类型，里面保存的实际元素类型为子类类型
调用各元素的特有方法时，借助instanceOf判断类型后进行向下转型

多态参数

方法定义的形参类型为父类类型，实参类型允许为子类类型

Object类

object类是类层次结构的根类，每个类都使用object作为超类，所有对象（包括数组）都要实现这个类的方法

equals方法

==和equals的对比

==是一个比较运算符
1.既可以判断基本类型，又可以判断引用类型
2.如果判断基本类型：判断的值是否相等
3.如果判断引用类型，判断的是地址是否相等，即判定是不是同一个对象

A a=new A();
A b=a;
A c=b;
a==c//true
b==c//true

equals是Object类中的方法
1.只能判断引用类型
2.默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等

实例;

 @Override
    public boolean equals(Object obj) {
        //判断如果比较的两个对象是同一个对象，则直接返回true
        if(this==obj)
            return true;
        if(obj instanceof Person)
        //类型相同菜可以进行后续比较
        {
            //向下转型，进行类型转换 得到obj的各个属性
            Person p=(Person) obj;
            return this.name.equals(p.name)&&this.age==p.age;
        }
        return false;

hashCode方法

hashCode方法返回对象的哈希码值，该方法是为了提高哈希表的性能

作用

1.提高具有哈希结构的容器的效率
2.两个引用，如果指向的是同一个对象，则哈希值一定是一样的
3.两个引用，如果指向的是不同对象，哈希值是不一样的
4.哈希值主要是根据地址号来的，不能完全将哈希值等价于地址
5.集合中的hashCode根据需要可以进行重写

toString方法

toString方法返回对象的字符串表示
默认返回：全类名（包名+类名getClass（）.getName（））+@+哈希值的十六进制

子类往往会重写toString方法，用于返回对象的属性信息
重写toString方法，打印对象或拼接对象时，会自动调用该对象的toString形式
当直接输出一个对象时，toString方法会被默认调用

System.out.println(monster);//等价于调用monster.toString();

finalize方法

当垃圾回收期确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法

1.当对象被回收时，系统会自动调用该方法的finalize方法，子类考研重写该方法，做一些释放资源，数据库连接，打开文件的操作
2.什么时候被回收：当某个对象没有任何引用时，jvm就认为这个对象是一个垃圾对象，就会使用回收机制来销毁该对象，在销毁该对象前，会先调用finalize方法
3.垃圾回收机制的调用，是由系统来决定的，即有自己的GC，也可以通过System.gc（）触发垃圾回收机制

断点调试

在整个断点调试的过程中，试运行状态，是以对象的运行类型来执行的

断点调试是指在程序的某一行设置一个断点，调试时，程序运行到这一行就会挺住，然后考研一步一步往下调试，调试过程中考研看到各个变量当前的值，出错的话，调试到出错的代码行即显示错位u，停下分析修改