Java基础知识点整理（三）

构造方法的递归调用

员工类

package day07;

/**
 * 员工类
 * @author yangzc
 *
 */
public class Emp {
    
    private int empno;  //工号
    private String ename;   //姓名
    private boolean gender; //性别
    private  double salary; //薪资
    
    public Emp(int empno, String ename, boolean gender, double salary) {
        super();//调用Object类里面的构造方法
        this.empno = empno;
        this.ename = ename;
        this.gender = gender;
        this.salary = salary;
    }

    public Emp() {
        super();
        // TODO Auto-generated constructor stub
    }

    public int getEmpno() {
        return empno;
    }

    public void setEmpno(int empno) {
        this.empno = empno;
    }

    public String getEname() {
        return ename;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }

    public boolean isGender() {
        return gender;
    }

    public void setGender(boolean gender) {
        this.gender = gender;
    }

    public double getSalary() {
        return salary;
    }

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

    @Override
    public String toString() {
        return "Emp [empno=" + empno + ", ename=" + ename + ", gender=" + gender + ", salary=" + salary + "]";
    }
    
}

程序员类

package day07;

/**
 * 程序员类
 * @author yangzc
 *
 */
public class SE extends Emp {
    
    private int hot;
 
    
    public SE(int empno, String ename, boolean gender, double salary, int hot) {
        super(empno, ename, gender, salary);//调用父类的构造方法初始化子类对象的4个属性
        this.hot = hot;
    }


    public SE() {
        this(-1,"undefined",false,5000.0,0);
    }

    
    public int getHot() {//查询接口
        return hot;
    }


    public void setHot(int hot) {//修改接口
        this.hot = hot;
    }
    
    
    @Override
    public void setSalary(double salary) {//定义子类的修改工资的接口
        if(salary>=0) {
            super.setSalary(salary);//调用父类的修改工资的接口
        }
    }


    public void show() {
        System.out.println(this.toString());
    }


    @Override
    public String toString() {
        return super.toString()+"SE [hot=" + hot + "]";
    }
    

    
}

测试

package day08;

import day07.SE;

public class SETest {

    public static void main(String[] args) {
        SE zhaoliu = new SE(1004,"赵六",false,9000.0,10);
        zhaoliu.setSalary(-10000.0);//通过子类对象调用子类的成员方法
        zhaoliu.show();//通过子类对象调用自己的成员方法
        
        //SE wangwu = new SE();
        //wangwu.show();
    }

}

分析：
运行程序，JVM进入到main方法里面，实例化赵六的时候，会进入到SE的有参构造方法里面，而该构造方法里面会调用父类Emp的构造方法，所以又会进入到Emp的构造方法里面，而Emp的构造方法里面通过super语句调用父类Object的构造方法，所以又会进入到Object类的构造方法里面，Object类的构造方法执行完后，回到Emp的构造方法里面初始化对象的empno, ename等属性，Emp的构造方法执行完后，回到SE的构造方法里面初始化对象的hot属性，SE的构造方法执行完后，回到main方法里面，将该对象赋给变量zhaoliu, 并继续执行后面的操作。

final关键字

1）使用final修饰的变量称为常量
2）使用final修饰的方法不能被重写
3）使用final修饰的类不能被继承，比如：String

image.png

重写Object类的equals方法

equals方法的作用
比较两个对象的内容是否相同

自动生成的equals方法的代码如下：

    @Override
    public boolean equals(Object obj) {
        if (this == obj)    //如果两个对象的内存地址是一样的
            return true;
        if (obj == null)    //如果另外一个对象obj是空的
            return false;
        if (getClass() != obj.getClass())   //如果两个对象的数据类型不一样
            return false;
        Student other = (Student) obj;      //强制转换
        if (sid != other.sid)               //如果当前学生的学号跟另外一个学生的学号不相等
            return false;
        return true;
    }

测试

Student ls = null;
Student zs = new Student();
System.out.println(zs.equals(ls));
System.out.println(ls.euqals(zs));//运行抛异常

变量的生命周期

局部变量的生命周期
函数（方法）里面声明的变量称为局部变量，局部变量的生命周期为：从该变量的声明开始，一直到函数执行结束
成员变量（属性）的生命周期
函数（方法）外面声明的变量称为成员变量（全局变量），成员变量的生命周期为：从对象创建开始，一直到对象被回收

Java垃圾回收机制（了解）

不论哪种语言的内存分配方式，都需要返回所分配内存的真实地址，也就是返回一个指针到内存块的首地址。Java中对象是采用new或者反射的方法创建的，这些对象的创建都是在堆（Heap）中分配的，所有对象的回收都是由Java虚拟机通过垃圾回收机制完成的。GC为了能够正确释放对象，会监控每个对象的运行状况，对他们的申请、引用、被引用、赋值等状况进行监控，Java会使用有向图的方法进行管理内存，实时监控对象是否可以达到，如果不可到达，则就将其回收。

image.png

Java内存泄漏与内存溢出（了解）

1）内存溢出 out of memory，是指程序在申请内存时，没有足够的内存空间供其使用，出现out of memory
2）内存泄露 memory leak，是指程序在申请内存后，无法释放已申请的内存空间，一次内存泄露危害可以忽略，但内存泄露堆积后果很严重，无论多少内存，迟早会被占光。
3）memory leak会最终会导致out of memory！
4）内存泄露是指无用对象（不再使用的对象）持续占有内存或无用对象的内存得不到及时释放，从而造成的内存空间的浪费称为内存泄露。内存泄露有时不严重且不易察觉，这样开发者就不知道存在内存泄露，但有时也会很严重，会提示你Out of memory。
5）那么，Java内存泄露根本原因是什么呢？长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄露，尽管短生命周期对象已经不再需要，但是因为长生命周期对象持有它的引用而导致不能被回收。

Java接口

使用interface关键字定义的数据类型称为接口。
1）接口里面定义的方法是抽象方法，访问权限默认是public
2）接口里面定义的变量是常量，并且默认是静态的，访问权限默认是public

定义接口的语法格式：

[访问权限] interface 接口名{
    ...
}

接口里面定义方法的语法格式：

返回值类型 方法名(数据类型 变量名,数据类型 变量名);

Java类实现（继承）接口的语法格式

class Student implements ICode,ITest{
    ...
}

使用class关键字定义的数据类型称为类，比如：
String,Math,Scanner,System,Integer,Random,Double,Student,Emp,SE,PM

类和接口都是引用类型
数组也是引用类型，比如：int[],String[]

int,short,byte,long,char,boolean,float,double都是基本类型

定义接口使用interface关键字

package day09;

/**
 * 编写程序的接口
 * @author yangzc
 *
 */
public interface ICode {
    boolean OPENSOURCE = true;//是否开源
    void javaProgram();
    void sqlProgram();
}

package day09;

/**
 * 测试程序的接口
 * @author yangzc
 *
 */
public interface ITest {
    void unitTest();
    void manualTest();
    void autoTest();
}

Java类实现（继承）接口使用implements关键字

package day06;

import day09.ICode;
import day09.ITest;

/**
 * 学生类
 * @author yangzc
 *
 */
public class Student implements ICode,ITest {
    public int sno;//学号
    public String sname;//姓名
    public boolean isMale;//性别
    public int age;//年龄
    public static int count=0;//学生的数量
    
    public Student() {
        count++;
    }


    @Override
    public void javaProgram() {
        System.out.println("System.out.println(\"hello world\");");
    }


    @Override
    public void sqlProgram() {
        System.out.println("select * from emp;");
    }


    @Override
    public void unitTest() {
        // TODO Auto-generated method stub
        
    }


    @Override
    public void manualTest() {
        // TODO Auto-generated method stub
        
    }


    @Override
    public void autoTest() {
        // TODO Auto-generated method stub
        
    }
    
    
    
}

Collection和Collections的区别

1）Collection是接口
2）Collections是工具类，支持对List集合进行排序
说明：
Collection里面的E是泛型，表示集合里面元素的数据类型。泛型E可以理解为是数据类型的变量，用来接收1个引用数据类型。

List集合和数组的比较

1）数组对象一旦被创建，它的大小是固定不变的
2）List集合的大小是可变的
3）数组和List集合都支持通过下标（索引）访问数据
4）数组只能存储相同类型的数据
5）List集合可以存储不同类型的数据，比如：

List