Java学习笔记---面向对象2（Object类、包和import、访问控制权限和内部类）

类之间的关系

1.泛化关系，类和类之间的继承关系及接口与接口之间的继承关系。
2.实现关系，类对接口的实现。
3.关联关系，类与类之间的连接，一个类可以知道另一个类的属性和方法，在 java 语言中使用成员变量体现。
4.聚合关系，是关联关系的一种，是较强的关联关系，是整体和部分的关系。一个代表整体，一个代表部分。
5.合成关系，是关系的一种，比聚合关系强的关联关系。
6.依赖关系，依赖关系是比关联关系弱的关系，在java 语言中体现为返回值，参数，局部变量和静态方法调用。

is-a、is-like-a、has-a

is-a：

public class A {
    public void method1() {}
}
public class B extends A { 
    public void method1() {}
}

is-like-a：

public interface I {
    public void method1() ;
}
public class A implements I { 
    public void method1() {
    //实现
    }
}

has-a：

public class A {
    private B b;
  }
public class B {

  }

Object类

1. Object 类是所有Java 类的根基类。
2. 如果在类的声明中未使用extends 关键字指明其基类，则默认基类为Object 类。

例如：

public class User {
 
    }
//相当于
public class User extends Object {

   }

toString()

toString返回该对象的字符串表示。
通常toString 方法会返回一个“以文本方式表示”此对象的字符串，Object 类的 toString 方法返回一个字符串，该字符串由类名加标记@和此对象哈希码的无符号十六进制表示组成，Object 类toString 源代码如下：
getClass().getName() + ‘@’ + Integer.toHexString(hashCode())

在进行String 与其它类型数据的连接操作时，如：
System.out.println(student);，它自动调用该对象的 toString()方法。
【代码示例】，覆盖Person 中的toString 方法

public class ToStringTest {
    public static void main(String[] args) { 
    Person person = new Person(); 
    person.id = 200;
    person.name = "张三";

//System.out.println(person.toString());
//输出结果为：{id=200, name=张三}
//因为println 方法没有带Person 参数的
//而Person 是Object，所以他会调用println(Object x)方法
//这样就是产生Object 对其子类Person 的指向，而在Person 中覆盖了父类Object的toString 方法，所以运行时会动态绑定
//Person 中的toString 方法，所以将会按照我们的需求进行输出
System.out.println(person);

}
}
//class Person extends Object { //和以下写法等同
class Person{
   int id;
   String name;
   public String toString() {
   return "{id=" + id + ", name=" + name + "}";
   }
}

finalize

垃圾回收器（Garbage Collection），也叫 GC，垃圾回收器主要有以下特点：
当对象不再被程序使用时，垃圾回收器将会将其回收。
垃圾回收是在后台运行的，我们无法命令垃圾回收器马上回收资源，但是我们可以告诉他，尽快回收资源（System.gc 和Runtime.getRuntime().gc()）。
垃圾回收器在回收某个对象的时候，首先会调用该对象的finalize 方法。
GC 主要针对堆内存。
单例模式的缺点。
当垃圾收集器将要收集某个垃圾对象时将会调用 finalize，建议不要使用此方法，因为此方法的运行时间不确定，如果执行此方法出现错误，程序不会报告，仍然继续运行。

==与equals方法

等号“==”，等号可以比较基本类型和引用类型，等号比较的是值，特别是比较引用类型，比较的是引用的内存地址。
例如：采用等号比较：

public class EqualsTest01 {
    public static void main(String[] args) {
     int a = 100;
     int b = 100;
//可以成功比较
//采用等号比较基本它比较的就是具体的值
    System.out.println((a == b)?"a==b":"a!=b");
    Person p1 = new Person(); 
    p1.id = 1001;
    p1.name = "张三";
    Person p2 = new Person(); 
    p2.id = 1001;
    p2.name="张三";
//输出为p1!=p2
//采用等号比较引用类型比较的是引用类型的地址（地址也是值）
//这个是不符合我们的比较需求的
//我们比较的应该是对象的具体属性，如：id 相等，或id 和name 相等
    System.out.println((p1 == p2)?"p1==p2":"p1!=p2");
    Person p3 = p1;
//输出为p1==p3
//因为 p1 和 p3 指向的是一个对象，所以地址一样
//所以采用等号比较引用类型比较的是地址
System.out.println((p1 == p3)?"p1==p3":"p1!=p3");

    String s1 = "abc";
     String s2 = "abc";
//输出s1==s2
System.out.println((s1==s2)?"s1==s2":"s11=s2");
    }
}
class Person{
    int id;
    String name;
}

例如：采用equals比较两个对象是否相等：

public class EqualsTest02 {
     public static void main(String[] args) {           
     String s1 = "abc";
     String s2 = "abc";
// 输出 s1==s2 
     System.out.println((s1==s2)?"s1==s2":"s1=s2");                    
     String s3 = new String("abc");
     String s4 = new String("abc");
     System.out.println((s3==s4)?"s3==s4":"s3!=s4");
//输出s3等于s4，所以确定string 的equals 比较的是具体的内容
     System.out.println(s3.equals(s4)? "s3 等于s4": "s3 不等于s4");
     Person p1 = new Person();
     p1.id = 1001;
     p1.name = "张三";
     Person p2 = new Person();
     p2.id = 1001;
     p2.name="张三";

//输出：p1 不等于 p2
//因为它默认调用的是Object 的equals 方法
//而Object 的equals 方法默认比较的就是地址,Object 的equals 方法代码如下：
//	public boolean equals(Object obj) {
//	return (this == obj);
//	}
//如果不准备调用父类的equals 方法，那么必须覆盖父类的equals 方法
行为
System.out.println(p1.equals(p2)? "p1 等于p2": "p1 不等于p2");
     }
}

class Person{
    int id;
    String name;
//覆盖父类的方法
//加入我们自己的比较规则  
    public boolean equals(Object obj) {
    if (this == obj) {
    return true;
    }
//确定比较类型为person
//同一类型，才具有可比性
    if (obj instanceof Person) {
//强制转换，必须实现知道该类型是什么
    Person p = (Person)obj;
//如果id 相等就认为相等
    if (this.id == p.id) { 
    return true;
    }
  }
    return false;
}

包

包其实就是目录，特别是项目比较大，java 文件特别多的情况下，我们应该分目录管理,在 java中称为分包管理。
1、包最好采用小写字母
2、包的命名应该有规则，不能重复，一般采用公司网站逆序。
如：com.Tencent.项目名称.模块名称
注意：package 必须放到 所有语句的第一行，注释除外。

import

当不在同一个包下的时候，需要采用import 引入，需要使用的类如果都在同一个包下就不需要 import 引入了，在实际开发过程中不应该这样做，必须建立包。

JDK 常用开发包
java.lang，此包 Java 语言标准包，使用此包中的内容无需import 引入
java.sql，提供了 JDBC 接口类
java.util，提供了常用工具类
java.io，提供了各种输入输出流

访问控制权限

java 访问级别修饰符主要包括：private、 protected 和public，可以限定其他类对该类、属性和方法的使用权限：

注意以上对类的修饰只有：public 和default，内部类除外。

内部类

在一个类的内部定义的类，称为内部类内部类主要分类：
实例内部类
局部内部类
静态内部类

实例内部类

创建实例内部类，外部类的实例必须已经创建。
实例内部类会持有外部类的引用。
实例内部不能定义static 成员，只能定义实例成员。

静态内部类

静态内部类不会持有外部的类的引用，创建时可以不用创建外部类。
静态内部类可以访问外部的静态变量，如果访问外部类的成员变量必须通过外部类的实例访问。

局部内部类

局部内部类是在方法中定义的，它只能在当前方法中使用。和局部变量的作用一样局部内部类和实例内部类一致，不能包含静态成员

匿名内部类

是一种特殊的内部类，该类没有名字。
实例使用匿名内部类：

public class InnerClassTest {
   public static void main(String[] args) {
    InnerClassTest innerClassTest = new InnerClassTest();
    innerClassTest.method1(new MyInterface() {
    public void add() {
    System.out.println("-----add	");
    }
  });
}
private void method1(MyInterface myInterface) {          
    myInterface.add();
    }
}

interface MyInterface {
    public void add();
}