面向对象
5.1、类与类之间的关系
5.1.1、继承关系
类和类之间的继承关系及接口与接口之间的继承
5.1.2、实现关系
类对接口的实现
5.1.3、关联关系
类与类之间的连接，一个类可以知道另一个类的属性和方法，在java语言中使用实例变量体现
5.2、Object类
● Object类是所有Java类的根基类
● 如果在类的声明中未使用extends关键字指明其基类，则默认基类为Object类，如：
public class User {
………..
}
相当于
public class User extends Object {
………..
}
5.2.1、toString()（一般都需要重写）
返回该对象的字符串表示。通常toString 方法会返回一个“以文本方式表示”此对象的字符串，Object 类的 toString 方法返回一个字符串，该字符串由类名加标记@和此对象哈希码的无符号十六进制表示组成，Object类toString源代码如下：
getClass().getName() + ‘@’ + Integer.toHexString(hashCode())
在进行String与其它类型数据的连接操作时，如：
System.out.println(student);，它自动调用该对象的 toString()方法
【代码示例】
public class ToStringTest01 {
public static void main(String[] args) {
int i = 100;
System.out.println(100);
Person person = new Person();
person.id = 200;
person.name = "张三";
//会输出Person@757aef
//因为它调用了Object中的toString方法
//输出的格式不友好，无法看懂
System.out.println(person);
}
}
//class Person extends Object { //和以下写法等同
class Person{
int id;
String name;
}
【代码示例】，覆盖Person中的toString方法
public class ToStringTest02 {
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 + "}";
}
}
5.2.2、finalize
垃圾回收器（Garbage Collection），也叫GC，垃圾回收器主要有以下特点：
● 当对象不再被程序使用时，垃圾回收器将会将其回收（当没有任何外界引用使用的时候，GC会在某个时间段进行回收）
● 垃圾回收是在后台运行的，我们无法命令垃圾回收器马上回收资源，但是我们可以告诉他，尽快回收资源（System.gc和Runtime.getRuntime().gc()）
● 垃圾回收器在回收某个对象的时候，首先会调用该对象的finalize方法
● GC主要针对堆内存
● 单例模式的缺点【因为不能被垃圾回收，会一直存在直到项目停止】
当垃圾收集器将要收集某个垃圾对象时将会调用finalize，建议不要使用此方法，因为此方法的运行时间不确定，如果执行此方法出现错误，程序不会报告，仍然继续运行
public class FinalizeTest01 {
public static void main(String[] args) {
Person person = new Person();
person.id = 1000;
person.name = "张三";
//将person设置为null表示，person不再执行堆中的对象
//那么此时堆中的对象就是垃圾对象
//垃圾收集（GC）就会收集此对象
//GC不会马上收集，收集时间不确定
//但是我们可以告诉GC，马上来收集垃圾，但也不确定，会马上来
//也许不会来
person = null;
//通知垃圾收集器，来收集垃圾
System.gc();
/*
try {
Thread.sleep(5000);
}catch(Exception e) {
}
*/
}
}
class Person{
int id;
String name;
//此方法垃圾收集器会调用
public void finalize() throws Throwable {
System.out.println("Person.finalize()");
}
}
注意以下写法
public class FinalizeTest02 {
public static void main(String[] args) {
method1();
}
private static void method1() {
Person person = new Person();
person.id = 1000;
person.name = "张三";
//这种写法没有多大的意义，
//执行完成方法，所有的局部变量的生命周期全部结束
//所以堆区中的对象就变成垃圾了（因为没有引用指向对象了）
//person = null;
}
}
class Person{
int id;
String name;
public void finalize() throws Throwable {
System.out.println("Person.finalize()");
}
}
5.2.3、==与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 class EqualsTest03 {
public static void main(String[] args) {
Person p1 = new Person();
p1.id = 1001;
p1.name = "张三";
Person p2 = new Person();
p2.id = 1001;
p2.name="张三";
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;
}
}
以上输出完全正确，因为执行了我们自定义的equals方法，按照我们的规则进行比较的，注意instanceof的使用，注意强制转换的概念。将父类转换成子类叫做“向下转型（造型）”，向下造型是不安全的。“向上转型（造型）”是安全，子类转换成父类，如：将Student转成Person,如Dog转成动物
5.3、包和import
5.3.1、包
包其实就是目录，特别是项目比较大，java文件特别多的情况下，我们应该分目录管理,在java中称为分包管理，包名称通常采用小写
/*
1、包最好采用小写字母
2、包的命名应该有规则，不能重复，一般采用公司网站逆序，
如：cn.imjcoder.exam.项目名称.模块名称
cn.imjcoder.exam
*/
//package必须放到 所有语句的第一行，注释除外
package cn.imjcoder.exam;
public class PackageTest01 {
public static void main(String[] args) {
System.out.println("Hello Package!!!");
}
}
运行出现类不能找到错误，提示给的很明显，如cn.imjcoder.exam.PackageTest01类不能找到，因为我们加入了包，所以我们的class文件必须放到和包一样的目录里才可以，这就是采用包来管理类，也就是采用目录来管理类，建立目录com/imjcoder/exam，采用java PackageTest01执行，同样出现上面的错误，如果采用了包在执行该类时必须加入完整的包名称，正确的执行方式为java cn.imjcoder.exam.PackageTest01
正确执行通过。
另外还有一点需要注意：必须在最外层包采用java来执行，也就是classpath必须设置在chapter03目录上，以chapter03目录为起点开始找我们的class文件
5.3. 2、import
如何使用包下的class文件
package cn.exam;
//采用import引入需要使用的类
//import cn.imjcoder.exam.model.User;
//import cn.imjcoder.exam.model.Student;
//import cn.imjcoder.exam.model.Employee;
//可以采用 * 通配符引入包下的所有类
//此种方式不明确，但简单
import cn.exam.model.*;
//package必须放到 所有语句的第一行，注释除外
//package cn.imjcoder.exam;
public class PackageTest02 {
public static void main(String[] args) {
User user = new User();
user.setUserId(10000);
user.setUserName("张三");
System.out.println("user.id=" + user.getUserId());
System.out.println("user.name=" + user.getUserName());
}
}
如果都在同一个包下就不需要import引入了，以上的示例都没有包，可以理解为都在同一个包下，在实际开发过程中不应该这样做，必须建立包
5.3.3、JDK常用开发包
- java.lang，此包Java语言标准包，使用此包中的内容无需import引入
- java.sql，提供了JDBC接口类
- java.util，提供了常用工具类
- java.io，提供了各种输入输出流
5.4、访问控制权限
java访问级别修饰符主要包括：private protected、public和default，可以限定其他类对该类、属性和方法的使用权限
| 修饰符 | 类的内部 | 同一个包里 | 子类 | 任何地方 |
|---|---|---|---|---|
| private | Y | N | N | N |
| default | Y | Y | N | N |
| protected | Y | Y | Y | N |
| public | Y | Y | Y | Y |
注意以上对类的修饰只有：public和default，内部类除外
5.4.1、private
【示例代码】
public class PrivateTest01 {
public static void main(String[] args) {
A a = new A();
//不能访问，private声明的变量或方法，只能在同一个类中使用
System.out.println(a.id);
}
}
class A {
private int id;
}
5.4.2、protected
【代码实例】，在同一个包下，建立类ProtectedTest01、A，并建立B继承A
public class ProtectedTest01 {
public static void main(String[] args) {
A a = new A();
a.method1();
A b = new B();
b.method1();
B b1 = new B();
b1.method3();
}
}
class A {
//采用protected声明的变量或方法只有子类或同一个包下的类可以调用
protected int id = 100;
public void method1() {
System.out.println(id);
}
protected void method2() {
System.out.println("A.method2()");
}
}
class B extends A {
public void method1() {
//可以正确调用
//因为和A在同一个包下
System.out.println(id);
}
public void method3() {
//可以正确调用
method2();
}
}
【代码示例】，在test1下建立类C1，在test2下建立ProtectedTest02和C2类
package test2;
import test1.C1;
public class ProtectedTest02 {
public static void main(String[] args) {
new C2().method2();
}
}
class C2 extends C1 {
public void method2() {
//可以调用，主要原因C2是C1的子类
//所以可以访问protected声明的变量
System.out.println(id);
method1();
}
}
class C3 {
public void method3() {
//不能在其他类中访问protected声明的方法或变量
//new C1().method1();
}
}
5.4.3、default
如果class不采用public修饰，那么此时的class，只能被该包下的类访问，其他包下无法访问
import test3.D;
public class DefaultTest01 {
public static void main(String[] args) {
D d = new D();
d.method1();
//不能访问，只有在一个类中或在同一个包下可以访问
//在子类中也不能访问
d.method2();
}
}
5.5、内部类
在一个类的内部定义的类，称为内部类
内部类主要分类：
● 成员内部类
● 局部内部类
● 静态内部类
● 匿名内部类
5.5.1、成员内部类
● 创建实例内部类，外部类的实例必须已经创建
● 实例内部类会持有外部类的引用
● 实例内部不能定义static成员，只能定义实例成员
public class InnerClassTest01 {
private int a;
private int b;
InnerClassTest01(int a, int b) {
this.a = a;
this.b = b;
}
//内部类可以使用private和protected修饰
private class Inner1 {
int i1 = 0;
int i2 = 1;
int i3 = a;
int i4 = b;
//实例内部类不能采用static声明
//static int i5 = 20;
}
public static void main(String[] args) {
InnerClassTest01.Inner1 inner1 = new InnerClassTest01(100, 200).new Inner1();
System.out.println(inner1.i1);
System.out.println(inner1.i2);
System.out.println(inner1.i3);
System.out.println(inner1.i4);
}
}
5.5.2、静态内部类
● 静态内部类不会持有外部的类的引用，创建时可以不用创建外部类
● 静态内部类可以访问外部的静态变量，如果访问外部类的成员变量必须通过外部类的实例访问
【示例代码】
public class InnerClassTest02 {
static int a = 200;
int b = 300;
static class Inner2 {
//在静态内部类中可以定义实例变量
int i1 = 10;
int i2 = 20;
//可以定义静态变量
static int i3 = 100;
//可以直接使用外部类的静态变量
static int i4 = a;
//不能直接引用外部类的实例变量
//int i5 = b;
//采用外部类的引用可以取得成员变量的值
int i5 = new InnerClassTest02().b;
}
public static void main(String[] args) {
InnerClassTest02.Inner2 inner = new InnerClassTest02.Inner2();
System.out.println(inner.i1);
}
}
5.5.3、局部内部类
局部内部类是在方法中定义的，它只能在当前方法中使用。和局部变量的作用一样
局部内部类和实例内部类一致，不能包含静态成员
public class InnerClassTest03 {
private int a = 100;
//局部变量，在内部类中使用必须采用final修饰
public void method1(final int temp) {
class Inner3 {
int i1 = 10;
//可以访问外部类的成员变量
int i2 = a;
int i3 = temp;
}
//使用内部类
Inner3 inner3 = new Inner3();
System.out.println(inner3.i1);
System.out.println(inner3.i3);
}
public static void main(String[] args) {
InnerClassTest03 innerClassTest03 = new InnerClassTest03();
innerClassTest03.method1(300);
}
}
5.5.4、匿名内部类
是一种特殊的内部类，该类没有名字
没有使用匿名类
public class InnerClassTest04 {
public static void main(String[] args) {
MyInterface myInterface = new MyInterfaceImpl();
myInterface.add();
}
}
interface MyInterface {
public void add();
}
class MyInterfaceImpl implements MyInterface {
public void add() {
System.out.println("-------add------");
}
}
使用匿名类
public class InnerClassTest05 {
public static void main(String[] args) {
/*
MyInterface myInterface = new MyInterface() {
public void add() {
System.out.println("-------add------");
}
};
myInterface.add();
*/
/*
MyInterface myInterface = new MyInterfaceImpl();
InnerClassTest05 innerClassTest05 = new InnerClassTest05();
innerClassTest05.method1(myInterface);
*/
InnerClassTest05 innerClassTest05 = new InnerClassTest05();
innerClassTest05.method1(new MyInterface() {
public void add() {
System.out.println("-------add------");
}
});
}
private void method1(MyInterface myInterface) {
myInterface.add();
}
}
interface MyInterface {
public void add();
}
/*
class MyInterfaceImpl implements MyInterface {
public void add() {
System.out.println("-------add------");
}
}
*/
7779
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
