JAVA SE -- 第八天

（全部来自“韩顺平教育”）

一、IDEA使用

１、IDE（集成开发环境）－IDEA

２、IDE（集成开发环境）－Eclipse

3、IDEA常用快捷键

• 删除当前行，默认是 ctrl + Y  （自己配置 ctrl + d）
• 复制当前行，（自己配置 ctrl + alt + 向下光标）
• 补全代码 alt + /
• 添加注释和取消注释 ctrl + / （第一次是添加注释，第二次是取消注释）
• 导入该行需要的类，先配置 auto import ，然后使用 alt + enter 即可
• 快速格式化代码 ctrl + alt + L
• 快速运行程序，（自己定义 alt + R）
• 生成构造器等 alt + insert
• 查看一个类的层级关系 ctrl + H
• 将光标放在一个方法上，输入 ctrl + B，可以定位到方法
• 自动的分配变量名，通过在后面＋ .var 

4、模板/自定义模板

file -> settings -> editor -> Live templates -> 查看有哪些模块快捷键/可以自己增加模板

二、包

1、三大作用

①区分相同名字的类

②当类很多时，可以很好的管理类

③控制访问范围

2、基本语法

package 包名；

3、包的本质：创建不同的文件夹/目录来保存类文件

4、命名规则

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

命名规范

一般是小写字母+小圆点

com.公司名.项目名.业务模块名

5、常用的包

一个包下，包含很多的类。Java中常用的包有：

java.lang.*      //lang包是基本包，默认引入，不需要再引入

java.util.*        //util，系统提供的工具包，工具类，使用Scanner

java.net.*       //网络包，网络开发

java.awt.*      //做java的界面开发，GUI

6、引入包

引入包的主要目的是要使用该包下的类

import 包；

注意：需要使用到哪个类，就导入哪个类即可，不建议使用*导入

7、注意事项和使用细节

①package的作用是声明当前类所在的包，需要放在类的最上面，一个类中最多只有一句package

②import指令位置放在package的下面，在类定义前面，可以有多句且没有顺序要求

三、访问修饰符

1、基本介绍

Java提供四种访问控制修饰符号，用于控制方法和属性（成员变量）的访问权限（范围）：

①公开级别：public修饰，对外公开

②受保护级别：protected修饰，对子类和同一个包中的类公开

③默认级别：没有修饰符号，向同一个包的类公开

④私有级别：private修饰，只有类本身可以访问，不对外公开

2、四种访问修饰符的访问范围

访问级别	访问控制修饰符	同类	同包	子类	不同包
公开	public	√	√	√	√
受保护	protected	√	√	√	×
默认	没有修饰符	√	√	×	×
私有	private	√	×	×	×

3、注意事项

①修饰符可以用来修饰类中的属性，成员方法以及类

②只有默认的和public才能修饰类，并且遵循上述访问权限的特点

③成员方法的访问规则和属性完全一样

四、OOP三大特征（封装，继承和多态）

（一）封装

1、基本介绍

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

封装的好处：隐藏实现细节

2、封装的步骤

①将属性进行私有化private   【不能直接修改属性】

②提供一个公共的（public）set方法，用于对属性判断并赋值

             public void setXxx(类型 参数名){      //Xxx表示某个属性

                  //加入数据验证的业务逻辑

                  属性 = 参数名；

             }

③提供一个公共的（public）get方法，用于获取属性的值

             public 数据类型 getXxx(){      //权限判断，Xxx表示某个属性

                  return xx；

             }

 3、案例

要求：不能随便查看人的年龄，工资等隐私，并对设置的年龄进行合理的验证。年龄合理就设置，否则给默认年龄，必须在1-120，年龄，工资不能直接查看，name的长度在2-6字符之间。

package com.hspedu.encap;

public class Encapsulation {
    public static void main(String[] args){
        Person person = new Person();
        person.setName("jack");
        person.setAge(15);
        person.setSalary(3000);
        System.out.println(person.info());
    }
}

class Person{
    public String name;
    private int age;
    private double salary;

    public void say(int n,String name){

    }
    //使用快捷键alt+insert快速构建get、set方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        if(name.length() >= 2 && name.length() <= 6) {
            this.name = name;
        }else{
            System.out.println("名字长度不对，需要（2-6）个字符，默认名字");
            this.name = "无名人";
        }
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age >=1 && age <= 120) {
            this.age = age;
        }else{
            System.out.println("你设置的年龄不对，需要在（1-120）,给默认年龄18");
            this.age = 18;
        }
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    //返回属性信息
    public String info(){
        return "信息为name=" + name + " age=" + age + " 薪水为" + salary;
    }
}

重点：

使用快捷键alt+insert快速构建get、set方法

4、将构造器和setXxxv结合

public Person(String name,int age,double salary){
    //this.name = name;
    //this.age = age;
    //this.salary = salary;
    //可以将set方法写在构造器中，这样仍可以验证
    setName(name);
    setAge(age);
    setSalary(salary);
}

（二）继承

1、基本介绍

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

2、基本语法

class 子类 extends 父类{

}

①子类就会自动拥有夫类定义的属性和方法

②父类又叫超类，基类

③子类又叫派生类

3、注意事项

①子类继承了所有的属性和方法，非私有的属性和方法可以在子类直接访问，但是私有属性和方法不能直接访问，要通过父类提供公共的方法去访问

②子类必须调用符类的构造器，完成父类的初始化

③当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用super去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过

④如果希望指定去调用父类的某个构造器，则显式的调用一下：super(参数列表)

⑤super在使用时，必须放在构造器第一行（super只能在构造器中使用）

⑥super()和this()都只能放在构造器第一行，因此这两个方法不能共存在一个构造器

⑦Java所有类都是Object类的子类，Object是所有类的基类

⑧父类构造器的调用不限于直接父类，将一直网上追溯直到Object类（顶级父类）

⑨子类最多只能继承一个父类（指直接继承），即Java是单继承机制

⑩不能滥用继承，子类和父类之间必须满足is-a的逻辑关系

（三）多态

1、基本介绍

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

2、多态的具体体现

        1）方法的多态

        2）对象的多态

①一个对象的编译类型和运行类型可以不一致

②编译类型在定义对象时，就确定了，不能改变

③运行类型是可以变化的

④编译类型看定义时 = 号的左边，运行类型看 = 号的右边

例：Animal animal = new Dog();     【animal编译类型是Animal，运行类型Dog】

animal = new Cat();      【animal的运行类型变成了Cat，编译类型仍然是Animal】

3、注意事项

①前提：两个对象（类）存在继承关系

②向上转型

a、本质：父类的引用指向了子类的对象

b、语法：父类类型 引用名 = new 子类类型();

c、特点：编译类型看左边，运行类型看右边

           可以调用父类中的所有成员（需遵守访问权限）

           不能调用子类中特有成员

           最终运行效果看子类的具体实现

③向下类型

a、语法：子类类型 引用名 = (子类类型) 父类引用；

b、只能强转父类的引用，不能强转父类的对象

c、要求父类的引用必须指向的是当前目标类型的对象

d、当向下转型后，可以调用子类类型中所有的成员

注意：属性没有重写之说！属性的值看编译类型

4、instanceOf比较操作符

用于判断对象的运行类型是否为XX类型或XX类型的子类型

５、Java的动态绑定机制

①当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定

②当调用对象属性的时候，没有动态绑定机制，哪里声明，哪里使用

6、多态的应用

①多态数组：数组的定义类型为父类类型，里面保存的实际元素类型为子类型

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

五、Super关键字

1、基本介绍

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

2、基本语法

①访问父类的属性，但不能访问父类的private属性

                super.属性名；

②访问父类的方法，不能访问父类的private方法

                super.方法名(参数列表)；

③访问父类的构造器

                super(参数列表)；       //只能放在构造器的第一句，只能出现一句！

3、super给变成带来的好处

①调用父类的构造器的好处（分工明确，父类属性由父类初始化，子类属性由子类初始化）

②当子类中有和父类中的成员（属性和方法）重名时，为了访问父类的成员，必须通过super。如果没有重名的，使用super、this、直接访问效果一致。

③super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员；如果多个基类（上级类）中都有同名的成员，使用super访问遵循就近原则、访问权限的相关原则

4、super和this的比较

区别点	this	super
访问属性	访问本类中的属性，如果本类没有此属性则从父类中继续查找	从父类开始查找属性
调用方法	访问本类中的方法，如果本类没有此方法则从父类中继续查找	从父类开始查找方法
调用构造器	调用本类构造器，必须放在构造器的首行	调用父类构造器，必须放在子类构造器的首行
特殊	表示当前对象	子类中访问父类对象

六、方法重写（overwrite）

1、基本介绍

方法覆盖（重写）就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，则说子类的这个方法覆盖了父类的方法。

2、注意事项

①子类的方法的参数列表、方法名称，要和父类方法的形参列表、方法名称完全一样

②子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类

③子类方法不能缩小父类方法的访问权限

3、重写和重载比较

名称	发生范围	方法名	形参列表	返回类型	修饰符
重载（overload）	本类	必须一样	类型，个数或者顺序至少有一个不同	无要求	无要求
重写（override）	父子类	必须一样	相同	子类重写的方法，返回的类型和父类返回的类型一致，或者是其子类	子类方法不能缩小父类方法的访问范围

七、Object类详解，垃圾回收机制

（一）equals方法

1、== 和equals 的对比

①== ： 既可以判断基本类型，又可以判断引用类型

②== ： 如果判断基本类型，判断的是值是否相等

③== ： 如果判断引用类型，判断的是地址是否相等，即判定是不是同一个对象

④equals：是Object类中的方法，只能判断引用类型

⑤默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等

2、重写equals方法

//重写Object的equals方法
public boolean equals(Object obj){
    //判断如果比较的两个对象是同一个对象，则直接返回true
    if(this == obj){
        return true;
    }

    //类型判断
    if(obj instanceof Person){   //是Person，此比较
        //进行向下转型，因为需要得到obj的各个属性
        Person p = (Person)obj;
        return this.name.equals(p.name) && this.age == p.age && this.gender == p.gender;
    }
    
    //如果不是Person，则直接返回false
    return false；
}

（二）hashCode方法

public int hashCode(){}

返回该对象的哈希码值。支持此方法是为了提高哈希表（例如：java.util.Hashtable）的性能。

 实际上，由Object类定义的hashCode方法确实会针对不同的对象返回不同的整数。（这一般是通过将该对象的内部地址转换成一个整数来实现的，但是Java的编程语言不需要这种实现技巧。）

总结：

①提高具有哈希结构的容器效率

②两个引用，如果指向的是同一个对象，则哈希值肯定是一样的

③两个引用，如果指向的是不同对象，则哈希值是不一样的

④哈希值主要根据地址号来的

 （三）toString方法

1、基本介绍

默认返回：全类名+@+哈希值的十六进制

子类往往重写toString方法，用于返回对象的属性信息

2、重写toString方法，打印对象或拼接对象时，都会自动调用该对象的toString形式

3、当直接输出一个对象时，toString方法会被默认的调用，比如System.out.println(monster);就会默认调用monster.toString()

（四）finalize方法

1、当对象被回收时，系统自动调用该对象的finalize方法。子类可以重写该方法，做一些释放资源的操作。

2、什么时候被回收：当某个对象没有任何引用时，则jvm就认为这个对象时一个垃圾对象，就会使用垃圾回收机制来销毁该对象，会先调用finalize方法。

3、垃圾回收机制的调用，是由系统来决定（既有自己的GC算法），也可以通过System.gc()主动触发垃圾回收机制

（五）断点调试（debug）

1、基本介绍

断点调试是指在程序的某一行设置一个断点，调试时，程序运行到这一行就会停住，然后可以一步一步往下调试，调试过程中可以看各个变量当前的值，出错的话，调试到出错的代码行即显示错误，停下。进行分析从而找到这个Bug。

2、快捷键

F7  ---   跳入，跳入方法内

F8  ---   跳过，逐行执行代码

shift + F8  ---   跳出，跳出方法

F9 --- resume，执行到下一个断点