类与对象

import java.io.Console;
import java.time.*;
import java.util.*;

class Employee{
    private String name;
    
    // final 变量要么在定义的时候赋值，要么在构造函数里初始化，否则会报错
    private final String f_name;
    
    private final StringBuilder sb;
    
    // shared by all the instance, 静态域 == 类域
    private static int count = 0;
    
    // 静态常量
    public static final double PI = 3.1411592654;
    
    // 初始化顺序: 定义时的默认值 -> 初始化块 -> 构造函数
    // 初始化块先于构造函数执行
    // static 初始化块用于初始化静态变量，不能初始化实例变量
    {
        name = "haha";
        System.out.println("in initial block");
    }
    
    // 构造函数一旦定义，就不会用系统默认的那个无参的构造函数
    // this 指向所构造的对象， this(name) 可以调用别的构造函数
    public Employee(String n) {
        this.name = n;
        f_name = "where am I";
        sb = new StringBuilder();
        
        // final 表示 sb 不能再指向别的StringBuilder了，但是可以更改sb中的内容
//        sb = new StringBuilder();  // no!
        sb.append("test");
        System.out.println("in constructor");
    }
    
    // other 的 name是私有的，类的方法可以访问类的任何私有变量
    public boolean equals(Employee other) {
        return name.equals(other.name);
    }
    
//    静态方法，不能访问实例域，不能操作对象，可访问静态域
    public static int sum(int a, int b) {
        return a + b;
    }
    
    public void setName(String n) {
        name = n;
    }
    
//    Java不支持析构器，自动回收
    
    // 方法名和参数类型构成了方法的签名，返回类型不是签名的一部分
    
    // java Employee 也可以单独执行这个
    public static void main(String[] args) {
     System.out.println("In Employee");
   }
}
public class Test{
    
    // Java按值传参，如果参数为基本主类型，则在这里面的操作不会更改原参数
    // 如果参数为对象（实际上为一个引用），则可以更改, 但是依然传的是值，不是引用
    // 不能让对象参数引用一个新的对象，只能改变这个对象的状态
    public static void changeEName(Employee e) {
        e.setName("Java");
    }
    public static void main(String[] args) {
        //类之间的关系
        // use-a 依赖 a调用b
        // has-a 聚合 a包含b
        // is-a  继承 
        
        // 编译的问题，如果文件组织形式是这样的：
        // -ETest (main)
        // -E
        // ETest中用了E，只需要 javac ETest.java即可在编译ETest的过程中发现没有E，继续编译E
        // 如果 E.java比E.class新，也会重新编译
        
        // public: 任何类的任何方法都能调用
        // private: 只有这个类自身的方法能够调用访问
        
        // 构造器与类同名，没有返回值
        // 不要在构造器中命名与实例域同名的变量
        
        // 不要编写返回引用可变对象的方法，如果一定要返回，则要先克隆，再返回
        // return xx.clone();
        
        // System.out 也是静态常量
        System.out.println(Employee.PI);
        
        System.out.println(Employee.sum(1,6));
        
        Employee e = new Employee("ck");
    }
}

 包

使用包的作用：确保类名的唯一性
没有在源文件中放置package语句，则这个源文件中的类就被放置在默认包中。
默认包没有名字

 

权限控制：默认的类，方法或者变量可以被同一个包中的所有方法访问

由于类中的变量在不加权限的情况下可以被包中的其他类看见，所以必须显式地添加private

 

(这地方可使用通配符*)

编译器和虚拟机的行为不同：

虚拟机的搜索顺序：

编译器的搜索顺序：

以用户顺序为优先，同样import则平等关系

非默认包，不声明package，则报错

如果从当前包中导入一个类，编译器就会搜索当前包中的所有源文件，以确定哪个源文件定义了这个类

类的设计技巧：

保证数据私有，保持封装；

要初始化数据，不能依赖默认类型；

不要在类中使用较多的基本类型，要用类替换；