Java学习概论第十二节

一、继承与多态

instanceof操作符
x instanceof A：检验x是否为类A的对象，返回值为boolean型。
要求x所属的类与类A必须是子类和父类的关系，否则编译错误。
如果x属于类A的子类B，x instanceof A值也为true。

public class Person extends Object {…} 
public class Student extends Person {…} 
public class Graduate extends Person {…}

public void method1(Person e) { 
	if (e instanceof Person) // 处理Person类及其子类对象 
	if (e instanceof Student) //处理Student类及其子类对象 
	if (e instanceof Graduate) //处理Graduate类及其子类对象 
}

二、其他关系

• 除了继承和实现外，依赖、关联、聚合、组成也是类之间的重要关系类型。

1、依赖关系

依赖关系是最常见的一种类间关系，如果在一个类的方法中操作另外一个
类的对象，则称其依赖于第二个类。

//依赖关系，Person依赖Car 
class Car { 
	void run(String city) { 
		System.out.println("汽车开到" + city);
	} 
} 
class Person {
	//Car类的对象作为方法的参数 
	void travel(Car car) { 
		car.run("青岛"); 
	} 
 }
public class DependentDemo { 
	public static void main(String[] args) { 
		Car car=new Car(); 
		Person p=new Person(); 
		p.travel(car); 
	} 
}

2、关联关系

关联关系比依赖关系更紧密，通常体现为一个类中使用另一个类的对象作
为该类的成员变量。

//关联关系，Person关联Car
class Car {
	void run(String city) { 
		System.out.println("汽车开到" + city);
	} 
} 
class Person { 
	Car car; // Car对象作为成员变量 
	Person(Car car) { 
		this.car = car; 
	} 
	void travel() { 
		car.run("青岛");
	}
}
public class AssociationDemo { 
	public static void main(String[] args)  {
		Car car = new Car(); 
		Person p = new Person(car); 
		p.travel(); 
	} 
}

3、聚合关系

聚合关系体现的是整体与部分的关系，通常表现为一个类（整体）由多个
其他类的对象（部分）作为该类的成员变量，此时整体与部分之间是可以分
离的，整体和部分都可以具有各自的生命周期。

 //聚合关系,Department由Employee聚合而成 
class Employee { 
	String name;
	Employee(String name) { 
		this.name = name;
	}
} 
class Department { 
	Employee[] emps; 
	Department(Employee[] emps) { 
		this.emps = emps;  
	} 
	void show() {
		// 循环遍历
		for (Employee emp : emps) {      								    				        								System.out.println(emp.name);
		}
	}
}
public class AggregationDemo { 
	public static void main(String[] args) { 
		Employee[] emps = { 
		new Employee("张三"), 
		new Employee("李四"), 
		new Employee("王五"), 
		new Employee("马六")}; 
	Department dept = new Department(emps); 
	dept.show(); 
	} 
}

4、组成关系

组成关系是比聚合关系要求更高的一种关联关系，体现的也是整体与部分
的关系，但组成关系中的整体与部分是不可分离的，整体的生命周期结束后
，部分的生命周期也随之结束。

//组成关系,汽车由各设备组成 
//发动机 
class Engine {......} 
// 底盘 
class Chassis {......} 
// 车身 
class Bodywork {......} 
// 电路设备 
class Circuitry {......}
class Car {
	// 汽车 
	Engine engine; 
	Chassis chassis;
	Bodywork bodywork;
	Circuitry circuitry;
	Car(Engine engine, Chassis chassis, Bodywork bodywork, Circuitry circuitry)   { 
		this.engine = engine; 
		this.chassis = chassis; 
		this.bodywork = bodywork; 
		this.circuitry = circuitry;
	}
}
public class CompositionDemo {
	public static void main(String[] args) {
		Engine engine = new Engine();
		Chassis chassis = new Chassis();
		Bodywork bodywork = new Bodywork();
		Circuitry circuitry = new Circuitry();
		Car car = new Car(engine, chassis, bodywork, circuitry); 
	} 
}

三、其他类

1、final关键字

final关键字表示“不可改变的、最终的”的意思，用于修饰变量、方法和
类：
• 1.当final关键字修饰变量时，表示该变量是不可改变的量，即常量；
• 2.当final关键字修饰方法时，表示该方法不可被子类重写，即最终方法；
• 3.当final关键字修饰类时，表示该类不可被子类继承，即最终类。
使用final修饰的方法不能被子类重写
final类：
• 由final修饰的类称终结类，不能被继承。由于安全性的原因或者是面
向对象设计的考虑，限定一些类不能被继承。
• final类不能被继承，保证了该类的唯一性。
• 对于一个类的定义已经很完善，不需再创建它的子类，也可以将其修饰
为final类。
格式：

final class finalClassName{
	...
}

使用final修饰的类不能被继承

2、抽象类

什么是抽象？
从众多的事物中抽取出共同的、本质性的特征，而舍弃其非本质的特征。
要抽象，就必须进行比较，没有比较就无法找到共同部分。
抽象类：
• 有一种类，自身也是不能实例化，这样的类称为抽象类。
• 有一种不能被自身实例化，且专门用来做父类的类，他就是我们要找的抽象类。
抽象类与抽象方法：
• 抽象类中往往存在一种方法，其只定义了方法的声明却不包含具体的实现。
• 抽象方法：只定义方法声明但不包含方法体
• 抽象类：包含抽象方法的类
• 一个抽象类中可以存在一个或多个抽象方法，抽象类中也可以不含有抽
象方法。
抽象类格式：

[访问控制符]  abstract class 抽象类名{
     ......
}
访问控制符 abstract  返回类型 方法名([参数列表]);

抽象方法在定义上与普通方法一样，也需要返回类型、方法，不同的是抽象方法没有方法体。
• 抽象类只表示一种抽象的概念，是描述其子类所共有的属性和方法，他不
能被实例化为一个对象，即不能用new关键字为抽象类对象分配空间。
• JAVA中的所有的对象都是通过类来描绘的，但并非所有的类都是用
来描绘对象的。
• abstract关键字不能修饰属性与构造方法。
Super关键字可以调用抽象类的构造方法：
抽象类和普通类相比，两个重点：
• 1、抽象类不能调用自身的构造方法创建对象，必须通过子类继承后，由子
类创建对象，而普通类可以调用自身的构造方法创建对象
• 2、抽象类可以包含抽象方法和非抽象方法，而普通类只能包含非抽象方法
。
总结：
• 抽象类不能调用自身的构造方法创建对象，必须通过子类创建后，由子类创建对象。
• 抽象方法只允许定义方法，不允许实现方法，即抽象方法不能有方法主体。
• 抽象类中可以不含有抽象方法，也可以含有一个或多个抽象方法。
• 若一个类中含有抽象方法，那么这个类必须被声明为抽象类。
• 若一个类继承了抽象类，那么子类必须实现所有的抽象方法，才可以生明子类为非抽象类，否则子类必须声明为抽象类。

3、内部类

在一个类的类体之内再定义一个类，该情况下外面的类称为“外部类”，里
面的类称为“内部类”。
• 成员内部类
• 局部内部类
• 静态内部类
• 匿名内部类
1、成员内部类
• 内部类可以很方便访问外部类的私有成员属性，并且外部类可以通过内
部类对象来访问内部类的私有成员属性。在外部类方法中可以访问成员
内部类的成员，同时也可以在外部类的外部直接实例化内部类的对象。
2、局部内部类
• 定义：在方法中定义的内部类称为局部内部类
• 局部内部类不能用public或private访问修饰符进行声明
• 局部内部类作用域被限定在声明该类的方法块中
• 局部内部类的优势在于，它可以对外界完全隐藏起来，除了所在的方法之
外，对其他方法而言是不透明的
• 局部内部类不仅可以访问包含它的外部类的成员，还可以访问局部变量，
但这些局部变量必须被声明为final
3、静态内部类
• 定义：使用static关键字修饰一个内部类，则该内部类称为“静态内部类”
• 静态内部类属于外部类的本身，而不属于外部类的某个对象
4、匿名内部类
• 匿名内部类就是没有名字的内部类。匿名内部类适合只需要使用一次的类，当创建一个匿名类时会立即创建该类的一个实例，该类的定义会立即消失，不能重复使用。
• 匿名内部类不能有构造方法；
• 匿名内部类不能定义任何静态成员、方法和类，但非静态的方法、属性、内部类是可以定义的；
• 只能创建匿名内部类的一个实例；
• 一个匿名内部类一定跟在new的后面，创建其实现的接口或父类的对象。