前景

今天主要是学习了几个小知识点，方法的参数，构造器，包，类的简单继承，总结一下。

方法参数

1、当方法的参数是基础类型的时候，当前的方法是无法修改原来的参数的，修改的也仅仅是拷贝的值。例如

package inheritance;

public class Test {

    public static void main(String[] args)
    {
        double a = 2;
        change(a);
        System.out.println("a的值为："+a);
    }

    public static void change(double x)
    {
        x+=3;
        System.out.println("x的值为"+x);
    }
}
x的值为5.0
a的值为：2.0

本来我们把变量a的值 x,想通过更改x的值来更改a，但是x的值改了，a的值未改，x只是对原来a的拷贝。

2、当方法的参数为对象的时候，可以改变对象参数的状态，因为对象引用会指向同一个对象，但是一个方法不能让对象参数引用一个新的对象，最简单的例子就是对象交换。举例：

package inheritance;

public class Test {

    private double salary;
    public static void main(String[] args)
    {
        double a = 2;
        change(a);
        System.out.println("a的值为："+a);

        Test ex1 = new Test();
        Test ex2 = new Test();

        ex2.setSalary(2000);
        ex1.setSalary(5000);
        changeSalary(ex1);
        System.out.println("ex1原来的工资为2000，ex1改后的工资为"+ex1.getSalary());

        changeObject(ex1, ex2);
        System.out.println("ex1和ex2交换了彼此，ex1的工资现在应该为,7000，实际为"+ex1.getSalary());
    }

    public static void change(double x)
    {
        x+=3;
        System.out.println("x的值为"+x);
    }

    public double getSalary()
    {
        return this.salary;
    }

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

    public static void changeSalary(Test x)
    {
        x.setSalary(7000);
    }

    public static void changeObject(Test a, Test b)
    {
        Test tmp = new Test();
        tmp = a;
        a = b;
        b = tmp;
        System.out.println("a->ex1现在的工资为"+a.getSalary());
        System.out.println("b->ex2现在的工资为"+b.getSalary());
    }
}
x的值为5.0
a的值为：2.0
ex1原来的工资为2000，ex1改后的工资为7000.0
a->ex1现在的工资为2000.0
b->ex2现在的工资为7000.0
ex1和ex2交换了彼此，ex1的工资现在应该为,7000，实际为7000.0

我们试图通过一个中间对象来交换a和b对象的引用，但是实际上只是拷贝了原来的引用，原来的引用并没有得到修改，只是拷贝的两个引用a和b进行了交换。

构造器

1、一个类中可以包含多个构造器，这些构造器根据不同的参数进行初始化实例域
2、可以在一个构造器中调用另一个构造器,通过this

包

public可以被任意类使用，private只能被自己的类所使用，而没有表明的则可以被同一个包的所有方法调用、

继承

1、子类继承父类的所有东西，可以在父类的基础上增加域、方法，和覆盖方法，但是不能删除原有的方法，所以通常把通用的方法作为超类的方法
2、this有两个用处，一引用隐式参数，二调用该类的其他构造器
super有两个用处，一调用父类的构造器，二是调用超类的方法

练习：
Employee.java

package inheritance;

import java.time.LocalDate;


public class Employee {

    private static int nextid = 0;

    private String name;
    private double salary;
    private LocalDate hireDay;
    private int id; 

    public Employee(String name, double salary, int year, int month, int day)
    {
        this.name = name;
        this.salary = salary;
        this.hireDay = LocalDate.of(year, month, day);
        this.id = 0;
    }

    public String getName()
    {
        return this.name;
    }

    public double getSalary()
    {
        return this.salary;
    }

    public LocalDate getHireDay()
    {
        return this.hireDay;
    }

    public void  raiseSalary(int percent)
    {
        this.salary += this.salary * percent / 100;
    }

    public void setId()
    {
        this.id = nextid;
        nextid++;
    }

    public static int getNextId() 
    {
        return nextid;
    }
}

Manager.java

package inheritance;

public class Manager extends Employee {

    private double bonus;

    public Manager(String name, double salary, int year, int month, int day) 
    {
        super(name, salary, year, month, day);
        this.bonus = 0;
    }

    public double getSalary()
    {
        return super.getSalary() + bonus;
    }

    public void setBonus(double bonus)
    {
        this.bonus = bonus;
    }

}

ManagerTest.java

package inheritance;


public class ManagerTest 
{
    public static void main(String[] args)
    {
        Manager boss = new Manager("XiaoXin", 8000, 2018, 10, 1);
        boss.setBonus(1000);

        Employee[] staff = new Employee[3];

        staff[0] = boss;
        staff[1] = new Employee("Zhangsan", 5000, 2018, 10, 1);
        staff[2] = new Employee("LiSi", 6000, 2018, 10, 2);

        for (Employee e : staff)
        {
            System.out.println("name: "+e.getName()+"'s salary :"+e.getSalary());
        }
    }

}