探索Java面向对象编程的奇妙世界(四)

⭐ 变量的分类和作用域

变量有三种类型：局部变量、成员变量(也称为实例变量)和静态变量。

局部变量、成员变量、静态变量的核心区别

⭐ 包机制(package、import)

包（package）相当于文件夹对于文件的作用。用于管理类、用于解决类的重名问题。

package

package 的使用有两个要点：

🐟	通常是类的第一句非注释性语句。
🐟	包名：域名倒着写即可，便于内部管理类。
1
2

【eg】package 的命名演示

com.oracle.test;
com.it.wang.test;
com.it.wang.view;
com.it.view.model;
1
2
3
4

注意:

🐟	写项目时都要加包，不要使用默认包。
🐟	com.wang 和 com.wang.car，这是两个完全独立的包。只是逻辑上看,后者是前者的一部分。
1
2

【eg】package 的使用

package com.oldwang;
	public class Test {
		public static void main(String[ ] args) {
			System.out.println("helloworld");
	}
}
1
2
3
4
5
6

⭐ 在 IDEA 项目中新建包

在 src 目录上单击右键，选择 new->package，创建 package

在 package 窗口上输入包名即可

点击 OK，即可在 src 下面看到包：

接下来，我们就可以在包上单击右键，新建类啦！

JDK 中的主要包

⭐ 导入类 import

如果要使用其他包的类，需使用 import，从而在本类中直接通过类名来调用，否则就需要书写类的完整包名和类名。

注意：

🐟	Java 会默认导入 java.lang 包下所有的类，因此这些类我们可以直接使用。
🐟	如果导入两个同名的类，只能用包名+类名来显示调用相关类：
🐟	java.util.Date date = new java.util.Date();
1
2
3

⭐ 静态导入

静态导入(static import): 其作用是用于导入指定类的静态属性和静态方法，这样我们可以直接使用静态属性和静态方法。

【eg】静态导入的使用

package oldwang;
import static java.lang.Math.*;//导入Math类的所有静态属性
import static java.lang.Math.PI;//导入Math类的PI属性

	public class Test{
		public static void main(String [ ] args){
			System.out.println(PI);
			System.out.println(random());
	}
}
1
2
3
4
5
6
7
8
9
10

执行结果如下所示：

⭐ 面向对象三大特征——继承

继承是面向对象编程的三大特征之一。继承让我们更加容易实现类的扩展。实现代码的重用，不用再重新发明轮子(don’t reinvent wheels)。

⭐ 继承的作用

🐟	代码复用，更加容易实现类的扩展
🐟	方便建模
1
2

⭐ 继承的实现

从英文字面意思理解，extends 的意思是“扩展”。子类是父类的扩展。现实世界中的继承无处不在。比如：

上图中，哺乳动物继承了动物。意味着，动物的特性，哺乳动物都有；在我们编程中，如果新定义一个Student类，发现已经有 Person类包含了我们需要的属性和方法，那么 Student类只需要继承 Person 类即可拥有 Person 类的属性和方法。

【eg】使用 extends 实现继承

	public class Test{
		public static void main(String[ ] args) {
			Student s = new Student("OldWang",183,"Java");
			s.rest();
			s.study();
	}
}
		class Person {
			String name;
			int height;

		public void rest(){
			System.out.println("休息一会！");
	}
}
		class Student extends Person {
			String major; //专业
		public void study(){
			System.out.println("在CSDN，学习Java");
	}
		public Student(String name,int height,String major) {
			//天然拥有父类的属性
			this.name = name;
			this.height = height;
			this.major = major;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

⭐ instanceof 运算符

instanceof 是二元运算符，左边是对象，右边是类；当对象是右面类或子类所创建对象时，返回 true；否则，返回 false。比如：

【eg】使用 instanceof 运算符进行类型判断

		public class Test{
			public static void main(String[ ] args) {
				Student s = new Student("OldWang",183,"Java");
				System.out.println(s instanceof Person);
				System.out.println(s instanceof Student);
	}
}
1
2
3
4
5
6
7

两条语句的输出结果都是 true。

⭐ 继承使用要点

🐟	父类也称作超类、基类。 子类：派生类等。
🐟	Java 中只有单继承，没有像 C++那样的多继承。多继承会引起混乱，使得继承链过于复杂，系统难于维护。
🐟	Java 中类没有多继承，接口有多继承。
🐟	子类继承父类，可以得到父类的全部属性和方法 (除了父类的构造方法)，但不见得可以直接访问(比如，父类私有的属性和方法)。
🐟	如果定义一个类时，没有调用 extends，则它的父类是：java.lang.Object。
1
2
3
4
5

⭐ 方法重写 override

子类重写父类的方法，可以用自身行为替换父类行为。重写是实现多态的必要条件。

方法重写需要符合下面的三个要点：

🐟	“= =”： 方法名、形参列表相同。
🐟	“≤”：返回值类型和声明异常类型，子类小于等于父类。
🐟	“≥”： 访问权限，子类大于等于父类。
1
2
3

【eg】方法重写

package oldwang;
/**
 * 测试方法的重写
 */
	public class TestOverride {
		public static void main(String[ ] args) {
			Horse h = new Horse();
			Plane p = new Plane();
			h.run();
			h.getVehicle();
			p.run();
	}
}

		class Vehicle { //交通工具类
		public void run() {
			System.out.println("跑....");
	}

		public Vehicle getVehicle(){
			System.out.println("给你一个交通工具！");
			return null;
	}
}
		class Horse extends Vehicle { // 马也是交通工具
			@Override
			public void run() {
			System.out.println("得得得....");
	}
			@Override
			public Horse getVehicle() {
			return new Horse();
	}
}
		class Plane extends Vehicle {
			@Override
			public void run() {
			System.out.println("天上飞....");
		}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

⭐ final 关键字

final 关键字的作用：

🐟	修饰变量: 被他修饰的变量不可改变。一旦赋了初值，就不能被重新赋值。final int MAX_SPEED = 120;
🐟	修饰方法：该方法不可被子类重写。但是可以被重载！ final void study(){}
🐟	修饰类: 修饰的类不能被继承。比如：Math、String 等。
1
2
3

⭐ 继承和组合

除了继承，"组合"也能实现代码的复用，“组合"核心是"将父类对象作为子类的属性”。

		public class Test{
			 public static void main(String[ ] args) {
 				Student s = new Student("OldWang",183,"Java");
 				s.person.rest(); //s.rest();
				s.study();
	 }
}
		class Person {
			 String name;
			 int height;
 	
 		public void rest(){
			 System.out.println("休息一会！");
	 }
 }
		class Student /*extends Person*/ {
 			Person person = new Person();
 			String major; //专业

		 public Student(String name,int height,String major) {
 			//拥有父类的对象，通过这个对象间接拥有它的属性和方法
 			this.person.name = name; //this.name = name;
 			this.person.height = height; //this.height = height;
 			this.person.rest();
			this.major = major;
	 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

组合比较灵活。继承只能有一个父类，但是组合可以有多个属性。所以，有人声称"组合优于继承，开发中可以不用继承"，但是，不建议大家走极端。

对于"is -a"关系建议使用继承，"has-a"关系建议使用组合。

比如：上面的例子，Student is a Person 这个逻辑没问题，但是：Student has a Person就有问题了。这时候，显然继承关系比较合适。

再比如：笔记本和芯片的关系显然是"has-a"关系，使用组合更好。