core java 第四章笔记

import java.util.*;
public class Employee {
    private static int nextid = 1;
    private String name;
    private double salary;
    private int id;
    public Employee(String n,double s)
    {
        name = n;
        salary = s;
        id = 0;
    }
    public String getname()
    {
        return name;
    }
    public double getsalary()
    {
        return salary;
    }
    public int getid()
    {
        return id;
    }
    public void setid()
    {
        id = nextid;
        nextid++;
    }
    public static int getnextid()
    {
        return nextid;
    }
    public static void mian(String[] args)
    {
        Employee e = new Employee("Harry",50000);
        System.out.println(e.getname()+" "+e.getsalary());
    }

        public static void main(String[] args) {
        // TODO 自动生成的方法存根
        Employee[] staff = new Employee[3];
        staff[0]=new Employee("TOM",40000);
        staff[1]=new Employee("Dick",60000);
        staff[2]= new Employee("Harry",65000);
        for(Employee e : staff)
        {
            e.setid();
            System.out.println("name="+e.getname()+"id="+e.getid()+"salary="+e.getsalary());
        }
        int n = Employee.getnextid();
        System.out.println("next available id = "+n);

    }

}

1/类中的方法被标记为public。关键字public意味着任何类的任何方法都可以调用这些方法。

2/在类中使用

private int a;

意味着只有类本身的方法能够访问这些实例域，而其他类的方法不能够读写这些域。

3/有时候，某个实例域本身就是对象，比如我们在类中定义一个private String name;name域是String类对象，类通常包括类型属于某个类类型的实例域。

4/构造器与类重名，当我们在构造一个类的对象的时候，构造器就会运行，以便将实例域初始化为所希望的状态。

5/构造器总是伴随着new操作符的执行被调用，不能对一个已经存在的对象调用构造器来达到重新设置实例域的目的。

比如：

staff[0]=new Employee("diyige",75000,1987,12,25);

A、构造器与类同名。

B、每个类可以有一个以上的构造器。

C、构造器可以有0个，1个，或者多个参数。

D、构造器没有返回值。

E、构造器总是伴随着new操作一起调用。

F、不要再构造器中构造与实例域重名的局部变量。

6/在每一个方法中关键字this表示隐式参数，比如;

public void raisesalary(double bypercent)

{

       double raise = this.salary*bypercent/100;

       this.salary = this.salary + raise;

}

在这个方法中，double bypercent被称为显示参数。

7/仅仅是查看并返回对象的状态而不对实例域做出修改的方法称为访问器方法。

对实例域做出修改的方法称为更改器方法。

8/可以将实例域定义为final，构建对象时必须初始化这样的域。也就是说，必须确保被一个构造器执行之后，这个域的值被设置，并且在后面的操作中，不能够对它进行修改。上面的程序中Employee类中的name就可以声明为final，因为对象构造后，名字这个值就不会再被修改。

10/static关键字代表着实例域属于类，不属于任何的对象。

例如在Math类中定义一个静态常量。

Public class Math()

{

       ······

       public static final double PI = 3.1415926;

       ······

}

在程序中就可以使用Math.PI的形式来获得这个常量。

如果static被省略，PI就会变成Math的一个实例域，那么就只有通过Math类的对象来访问PI，而且每一个Math对象都有它自己一份对PI的拷贝。

11/静态方法是一种不能向对象操作的方法，例如：Math类中的pow（）方法就是一个静态方法。

Math.pow(x,a);

在运算中不使用任何的Math对象。也就是说没有隐式参数。所以也可以认为是一个没有this参数的方法。在Employee类中，静态方法不能访问id实例域，因为它不能操作对象，但是静态方法可以访问自身的静态域。

例如：

public static int getnextid()

{

   return nextId;

}

可以通过类名调用这个方法：

int n = Employee.getnextid();

也是可以省略掉static的，但是如果省略掉就必须通过Employee类的对象来调用这个方法。

一般两种情况使用静态方法：

A：一个方法不需要访问对象的状态，其所需要的参数都是通过显式参数提供。

B：一个方法只需要访问类的静态域。

我们最常见的main方法也是一个静态的方法，因为它不对任何的对象进行操作。当我们启动eclipse的时候还没有一个对象呢。

12/程序设计语言中将参数传递给方法有三种方式：

按值调用：表示方法接受的是调用者提供的值。

引用调用：表示方法接受的是调用者提供的变量地址。

名称调用：这种传递方式已经成为历史。

在Java的世界里，总是采用按值调用。

方法参数的两种类型：

A.基本数据类型

B.对象引用

当java进行基本数据类型行的引用的时候，不会改变其数值。进行对象引用的时候，则会改变。

13/在编写构造器的时候可以在每一个参数的前面加上一个a，增强代码的可读性。

14/如果在构造器中的第一个语句形如this(···);这个构造器将调用同一类的 另一个构造器，这样公共的构造器代码只编写一次就可以了。

15/Java允许使用包将类组织起来。使用包的主要原因是确保类名的唯一性。为了保证包名的绝对唯一性，sun公司建议将公司的因特网域名以逆序的形式作为包名。

一个类可以使用所属包的所有类，以及其他包的公有类。我们可以采用两种方式，第一种是在每个类名前添加完整的包名。例如：

java,util.Date today = new java.util.Date();

这种方式真的很残废。

另外一种是用

import java.util.*;

就可以导入java.util包中的所有类。

Import java.util.Date;

可以导入一个包中的特定类。