主要记录Java三大特性笔记

/*IDE开发工具（以下内容均为查看韩顺平老师的课程，第八章的笔记，方便后期查看）
 修改快捷键： File -> setting -> Keymap  -> Editor Actions

 1. 删除行：默认是ctrl+Y 自己配置 Ctrl + D
 2. 复制当前行: 自己配置 ctrl + alt + 向下光标
 3. 补全代码: Alt + /
 4. 添加注释和取消注释： Ctrl + /
 =======================================
 5. 导入该行需要的类： 修改快捷键：File -> setting ->Editor  -> General -> Auto Import
 			 勾上： Add...     Optimize..
              快捷键： Alt + Enter
6. 快速格式化代码：  Ctrl + Alt + L
 7. 快速运行程序： Shift + F10  自己配置为  （Alt + R）

 ======================================
 8. 生成构造器： Alt + Insert
 9. 查看一个类的层级（继承）关系  Ctrl + H
 10. 把光标放在一个方法上，输入 Ctrl + B 可以定位到方法
 11. 自动的分配变量名，通过在后面加 .var
*/

//模板/自定义模板     可以高效的完成开发
// file -> setting -> editor -> live templates ->

包

包的本质： 实际上就是创建不同的文件夹/目录来保存类文件
包的三大作用：
    1.区分相同名字的类
    2.当类很多时，可以很好的管理类
    3.控制访问范围
包的命名规则： 只能包含数字，字母，下划线，小圆点，但不能用数字开头，
            不能是关键字或保留字
    命名规范： 一般是小写字母+小圆点
            com.sina.crm.user //用户模块
            com.sina.crm.order//订单模块
常用包：
java.lang.*	// lang包是基本包，默认引入，不需要再引入
java.util.* // util包，系统提供的工具包，工具类，如：Scanner
java.net.*	// 网络包，网络开发
java.awt.*	// 做java的界面开发 ，GUI

访问修饰符

                本类        同包            子类           不同包
public          true        true            true           true
protected       true        true            true           false
默认            true        true            false          false
private         true        false           false          false

修饰 类只有 public  和 默认

封装

介绍：就是把抽象出的数据【属性】和对数据的操作【方法】封装在一起，数据被保护在内部，
	程序的其他部分只有通过被授权的操作【方法】，才能对数据进行操作。
好处：
    1.隐藏实现细节：方法
    2.可以对数据进行验证，保证安全合理
实现：
    1.对属性进行私有化private
    2.提供一个公共的(public)set方法，用于对属性判断并赋值
    3.提供一个公共的(public)get方法，用于获取属性的值

继承

继承给编程带来的便利
1、代码的复用性提高了
2、代码的扩展性和维护性提高了

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

继承的本质分析（重要）
    当子类对象创建好后，建立查找的关系

查找：
// ? ->这时请大家注意，要按照查找关系来返回信息
//（1）首先看本类是否有该属性
//（2）如果本类有这个属性，并且可以访问，则返回信息
//（3）如果本类没有这个属性，就看父类有没有这个属性（如果父类有该属性，并且可以访问，就返回信息...）
//（4）如果父类没有，就按照(3) 的规则，继续找上级父类，直到Object ...
// 提示：如果查找的过程中，找到了，但是不能访问，则报错 cannot access
//       如果查找的过程中，没有找到，则提示属性不存在

Super

介绍：super代表父类的引用，用于访问父类的属性，方法，构造器
语法： super.属性名   
			super.方法名(参数列表)         
		 super(参数列表)  :只能放在构造器的第一句，只能在构造器中出现一句
细节：
 1.调用父类的构造器的好处（分工明确，父类属性由父类初始化，子类的属性由子类初始化）
 2.当子类中有和父类中的成员（属性和方法）重名时，为了访问父类的成员，必须通过super。
 	如果没有重名，使用super、this 直接访问是一样的效果
 3.super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员；
   如果多个基类中都有同名的成员，使用super访问遵循就近原则 A -> B -> C ,当然也需要遵循访问权限的相关规则

对比：
        区别点                 this                     super
1.     访问属性     访问本类中的属性，如果本类       从父类开始查找属性
                    没有此属性,则从父类中继续查找

2.     调用方法     访问本类中的方法，如果本类       从父类开始查找方法
                    没有此方法,则从父类中继续查找

3.     调用构造器    调用本类构造器，必须放在构造器首行   调用父类的构造器，必须放在子类构造器首行

4.      特殊        表示当前对象                    子类中访问父类对象

方法重写也叫方法覆盖

介绍：方法覆盖（重写）就是子类有一个方法，和父类的某个方法的名称，返回类型，参数一样，
	返回类型可以是父类的子类，那么我们就说子类的这个方法覆盖了父类的方法
细节：
    1、子类的方法形参列表，方法名称 要和父类方法的形参列表，方法名称完全一样
    2、子类方法的返回类型和 父类方法返回类型一样，或者是父类返回类型的子类 
    		如： 父类 返回Object 子类返回 String
       父类： public Object getInfo(){}    子类：  public String getInfo(){}
    3、子类方法 不能缩小父类方法的访问权限 public > protect > 默认 > private
       父类： void sayOk(){}                子类： public void say(){}


对比
                    发生范围     方法名         形参列表                               返回类型                            修饰符
重载（Overload）    本类         必须一样        类型，顺序，个数至少有一个不同         不影响                              不影响

重写（Override）    父子类       必须一样        相同                            子类重写的方法和父类返回类型            子类方法不能缩小父类方法的访问范围
                                                                                 一致，或者是父类返回类型的子类

多态：方法或者对象具有多种形态，是oop的第三大特征，是建立在封装和继承基础之上

多态的具体体现：
1. 方法的多态
    重写和重载体现多态
2. 对象的多态（核心，重点，困难） 背下来
    (1)一个对象的编译类型和运行类型可以不一致
    (2)编译类型在定义对象时，就确定了，不能改变
    (3)运行类型时可以变化的
    (4)编译类型看定义时 = 号的左边，运行类型看 = 号的右边
    Animal animal = new Dog(); animal 编译类型是Animal，运行类型 Dog
    animal = new Cat();        animal 的运行类型编程了Cat,编译类型仍然是Animal

多态的前提是：两个对象（类）存在继承关系
多态的向上转型：
1.本质：父类的引用指向子类的对象
2.语法：父类类型  引用名 = new 子类类型();
3.特点：（1）编译类型看左边，运行类型看右边。
        （2）可以调用父类中的所有成员（需遵循访问权限）
        （3）不能调用子类中特有成员（因为在编译阶段，能调用哪些成员，是由编译类型来决定的）
        （5）最终运行效果看子类(运行类型)的具体实现，即调用方法时，按照从子类(运行类型)开始查找方法，
        		然后调用，规则和之前的方法调用规则一致（子类->父类->...->Object）

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

多态注意事项和细节讨论
1. 属性没有重写之说！属性的值看编译类型
2. instanceOf 比较操作符，用于判断对象的运行类型是否为XX类型或者XX类型的子类型

java的动态绑定机制（非常重要）背下来
1.当调用对象方法的时候，该方法会和该对象的运行类型绑定
2.当调用对象属性时，属性没有动态绑定机制，哪里声明，哪里使用

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

Object类详解

==:基本数据类型比较的是值，引用数据类型比较的是地址(判断两个对象是不是同一个对象)

equals方法：
    是Object 类中的方法，只能判断引用类型
    默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等，如：Integer,String

hashCode方法：
    1.提高具有哈希结构的容器的效率
    2.两个引用，如果指向的是同一对象，则哈希值肯定是一样的
    3.两个引用，如果指向的是不同对象，则哈希值是不一样的
    4，哈希值主要根据地址号来的！不能完全将哈希值等价于地址

toString方法：
    默认返回： 全类名+@+哈希值的十六进制
    重写toString方法，打印对象或者拼接对象时，都会自动调用该对象的toString形式
    当直接输出一个对象时，toString方法会被默认的调用 System.out.println(monster); 
    	//就会默认调用 monster.toString();

finalize方法：
    1.当对象被回收时，系统自动调用该对象的finalize方法，子类可以重写该方法，做一些释放资源的操作
    2.什么时候别回收：当某个对象没有任何引用时，则jvm就认为这个对象是一个垃圾对象，
    	就会使用垃圾回收机制来销毁对象，在销毁对象前，会调用finalize()方法。
    3.垃圾回收机制的调用，是由系统来决定的（即有自己的GC算法），也可以通过System.gc()主动触发
    	垃圾回收机制
    我们在实际开发中，几乎不会运用finalize,所以更多就是为了应付面试

断点调试（debug）：

重点：在断点调试过程中，是运行状态，是以对象的运行类型来执行的。
断点调试介绍：
    1.断点调试是指在程序的某一行设置一个断点，调试时，程序运行到这一行就会停住，
    	然后你可以一步一步往下调试，调试过程中,可以看各个变量当前的值，出错的话，
    	调试到出错的代码行即显示错误，停下。进行分析而从找到这个Bug
    2.断点调试是程序员必须掌握的技能
    3.断点调试也能帮助我们查看java底层源代码的执行过程，提高程序员的java水平
断点调试的快捷键：
    F7(跳入) F8(跳过) shift + F8(跳出) F9（resume,指向到下一个断点）
    F7:跳入方法内
    F8:逐行执行代码
    shift + F8:跳出方法

基础不太好，或者需要查漏补缺的同学，强烈推荐
韩顺平 零基础30天学会Java