JavaSE学习笔记-Day4

在昨天的学习中，已经完成了Java面向对象的基础内容，今天开始步入Java面向对象的进阶学习，将从Java面向对象的三个特性：封装、继承、多态作为主线学习。

一. 封装性

封装（Encapsulation）是面向对象方法的重要原则，就是把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。

怎么理解封装呢？按照我自己的见解，人就是一个封装的东西，我们人可以实现的功能多了去了，吃饭、消化、免疫等等，这些具体实现都暴露在视野里吗？显然没有，每部分的功能实现都封装了起来。当然，还有一些是必须要暴露出的，如五官啥的，像这种有选择的暴露出一些简单内容，复杂实现和没必要暴露的就“隐藏起来”，这就是封装吧。

封装在Java中的具体体现就两方面：

1. 所有成员变量都用修饰符private修饰；
2. 方法就是封装的另一种体现（并不是把所有内容都写在main方法里）。
   1）提供相应的get/set方法来访问相关成员变量，这些方法通常是public修饰的，以提供对属性的赋值与读取操作。（标准类还记得不，一样的）
   2） 一些只用于本类的辅助性方法可以用private修饰，希望其他类调用的方法用public修饰。

封装的优点：

1. 提高代码的安全性。
2. 提高代码的复用性。
3. “高内聚”：封装细节，便于修改内部代码，提高可维护性。
4. “低耦合”：简化外部调用，便于调用者使用，便于扩展和协作。

二. 访问控制符

在开始学习到今天，我们遇见了很多次访问控制符——public private。那么它们具体是什么含义呢？访问控制符只有这两个吗？

Java是使用“访问控制符”来控制哪些细节需要封装，哪些细节需要暴露的。 Java中4种“访问控制符”分别为private、default、protected、public，它们说明了面向对象的封装性，所以我们要利用它们尽可能的让访问权限降到最低，从而提高安全性。
其访问权限范围如图所示：

1. private 表示私有，只有自己类能访问。
2. default表示没有修饰符修饰，只有同一个包的类能访问。
3. protected表示可以被同一个包的类以及其他包中的子类访问。
4. public表示可以被该项目的所有包中的所有类访问。

注意：

1. 这里的访问控制符，指的是对成员方法和成员变量的修饰。
2. 之前就强调过，cn.zjb和cn.zjb.test 这两个包是不同包，是独立的，没有包含关系。

这里出现了“子类”这个概念，我们就来学习一下啥是子类吧！

三. 继承性

在学继承前先来说个写代码时会遇见的情况吧：
假设我们写了两个类，一个叫Animal类，另一个叫Dog类，具体定义如下：

我们发现它们之间有关系，Animal类的东西，在Dog类都能找到，想想也是，它们本身就是包含关系——狗是动物。那么遇到这种情况，我们在写完Animal类的代码后，在写Dog类相同东西时又得重写一遍，人都是懒的嘛，自然不愿意做重复无意义的工作，所以Java为我们引进了“继承”这个概念。继承让我们更加容易实现类的扩展。 比如，我们定义了Animal类，再定义Dog类就只需要扩展Animal类即可，实现了代码的重用。

继承（extends）是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。我们一般叫这个已有的类为父类或基类；叫这个派生出来的类为子类或者派生类，熟记这两种叫法在不同情况下有利于我们更好理解继承。

具体用法：

父类名 extends 子类名{}

继承的几大特点：

1. .Java中只有单继承，就是一个类只能有一个父类。
2. 子类继承父类，可以得到父类的全部属性和方法 (除了父类的构造方法)，但不见得可以直接访问(如，父类私有的属性和方法，这就得看访问权限了)。
3. 如果定义一个类时，没有调用extends，则它的父类是：java.lang.Object。（java.lang包不用手写导入，编译器会自动补上extends Object）

那么现在，在上面的例子中，我们写Dog类时不用再写重复的代码了，让它继承Animal类即可：

不过现在又有一个问题了，在Dog类中的eat方法和Animal类中的eat方法是一个方法吗？不是！父类是吃东西而子类是吃骨头，这是不一样的，于是我们就有必要学习一下方法的重写这个概念。

四. 方法的重写

子类通过重写（override）父类的方法，可以用自身的行为替换父类的行为。
方法的重写需要符合下面的三个要点：

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

来敲敲代码测试一下：

package cn.zjb.test;
/**
 * 测试方法的重写（覆盖）
 * @author 张坚波
 *
 */
public class TestOverride {
	public static void main(String[] args) {
		Dog d=new Dog();
		d.eat(); //重写，子类的eat方法
		System.out.println(d.height); //public修饰 可以使用，默认值0
//		System.out.println(d.num); //错误的，private修饰，子类无法使用
//		System.out.println(d.printClass()); //错误，子类无法使用
//		System.out.println(d.Animal()); //错误，子类不能继承父类构造方法 
		
	}
}

class Animal{
	public int height;
	public int weight;
	private int num;
	//父类无参构造方法
	public Animal() { 
	}
	//父类两个参数构造方法
	public Animal(int height,int weight) {
		this.height=height;
		this.weight=weight;
	}
	public void eat() {
		System.out.println("父类的方法");
	}
	private void printClass() {
		System.out.println("这是父类");
	}
	Animal creatNew() {
		return new Animal(170,60);
	}
}

class Dog extends Animal{
	
	/*
	 * 错误写法，子类访问权限小于父类了
	void eat() {
		System.out.println("子类的方法");
	}
	*/
	
	@Override
	public void eat() {
		System.out.println("子类的方法");
	}

	//对的，子类返回值类型小于父类
	@Override
	Dog creatNew() {
		return new Dog();
	}
	
}

五. instanceof 运算符

instanceof是二元运算符，左边是对象，右边是类；当对象是右面类或子类(子类的子类也可，以此类推)所创建对象时，返回true；否则，返回false。

System.out.println(dog instanceof Animal);//true

六. Object类

Object类位于java.lang包，是Java继承树的根节点！来康康Object类都有啥：

这种单继承关系正好对应的就是树这个数据结构！

哦！真多东西，我们需要掌握的就两个方法：toString()和equals(Object)！

1. toString方法：
   Object类中定义有public String toString()方法，其返回值是 String 类型。Object类中toString方法的源码为：

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

根据如上源码得知，默认会返回“类名+@+16进制的hashcode”。在打印输出或者用字符串连接对象时，会自动调用该对象的toString()方法。

2. equals方法;
   Object类中定义有：public boolean equals(Object obj)方法，提供定义“对象内容相等”的逻辑。 Object 的 equals 方法默认就是比较两个对象的hashcode，是同一个对象的引用时返回 true 否则返回 false。这个方法是被重写最多的方法，因为判断两个对象是否相同，不同类有不同的方法。equals方法的源码如下：

 public boolean equals(Object obj) {
        return (this == obj);
    }

这里使用的“==”就是判断比较双方是否相同。如果是基本类型则表示值相等，如果是引用类型则表示地址相等即是同一个对象。

我们可以重写这两个方法，来写个程序吧：

package cn.zjb.test;
/**
 * 测试Object类的两个方法，并重写它们
 * @author 张坚波
 *
 */		
public class TestObject {
	public static void main(String[] args) {
		Person p=new Person(10);
//		System.out.println(p.toString()); //没重写时，结果：cn.zjb.test.Person@15db9742
		System.out.println(p.toString());
		Person p2=new Person(10);
//		System.out.println(p.equals(p2)); //没重写时，结果：false，两个对象
		System.out.println(p.equals(p2));
	}
}

class Person{
	int id;
	
	public Person(int id) {
		this.id=id;
	}
	
	@Override
	public String toString() {
		return "id是："+id;
	}

	@Override
	public boolean equals(Object obj) {
		if(obj==null)
			return false;
		else if(obj instanceof Person){
			Person s=(Person) obj; //对象的向下转型，马上学！
			if(s.id==this.id)
				return true;
			else
				return false;
		}else
			return false;
	}
	
}

运行结果如下：

七.super关键字

super是直接父类对象的引用（与this正好形成对比，this是当前对象的引用）。可以通过super来访问父类中被子类覆盖的方法或属性。

使用super调用普通方法，语句没有位置限制，可以在子类中随便调用。

若是构造方法的第一行代码没有显式的调用super(…)或者this(…);那么Java默认都会调用super(),含义是调用父类的无参数构造方法。这里的super()可以省略。

注意：在构造方法中，this(…)和super(…)都必须要在第一句，换句话说，就是写了super就不能写this,写了this就不能写super，“一山不容二虎”！

因为有默认的super()，这里还牵扯到一个问题，当我们创建一个类当前对象时，就沿着当前类一致向上追述直到Object类，再依次向下执行类的构造方法。也就是说，在调用对象的构造方法时，父类的构造方法总比本类构造方法先被调用。

package cn.zjb.test;
/**
 * 测试super 以及创建对象时构造方法的调用
 * @author 张坚波
 *
 */
public class TestSuper {
	public static void main(String[] args) {
		new Boy();
	}
}

class Person1{
	public Person1() {
		System.out.println("Person类无参构造方法执行！");
	}
}
 class Teenager extends Person1{
	 int age;
	 public Teenager() {
		 this(18);
		 System.out.println("Teenager类无参构造方法执行！");
	 }
	public Teenager(int age) {
		 this.age=age;
		 System.out.println("Teenager类age形参构造方法执行！");
	 }
 }
class Boy extends Teenager{
	public Boy() {
		System.out.println("Boy类无参构造方法执行！");
	}
}

运行结果如下：

静态初始化块：
构造方法用于对象的初始化!静态初始化块，用于类的初始化操作，相当于对类变量赋初值!在静态初始化块中不能直接访问非static成员。

静态初始化块执行顺序：

1. 上溯到Object类，先执行Object的静态初始化块，再向下执行子类的静态初始化块，直到我们的类的静态初始化块为止。
2. 构造方法执行顺序和上面顺序一样!
3. 静态初始化块在程序中只执行唯一的一次！
4. 静态初始化块的执行优先级比构造方法高，执行完所有的静态初始化块才按父类到子类的顺序执行构造方法！

八. 成员变量和成员方法在继承中的查找

属性/方法查找顺序：(比如：查找变量h)

1. 查找当前类中有没有属性h
2. 依次上溯每个父类，查看每个父类中是否有h，直到Object
3. 如果没找到，则出现编译错误。
4. 上面步骤，只要找到h变量，则这个过程终止。

注意！这个过程和构造方法是不一样的！

九. 多态性

多态(polymorphism)指的是同一个方法调用，由于对象不同可能会有不同的行为。多态，字面理解——多种形态，比方说，Dog类和Animal类，狗是动物吗？毫无疑问，所以它有狗形态，还有动物形态！所以说，动物形态的东西可以是动物类的对象，也可以是它子类的对象，那么某个动物类的东西表现出来的行为（方法的调用）也可以是子类对象的（当然父类也有这种行为），这就是多态。
多态的要点：

1. 多态是方法的多态，不是属性的多态(多态与属性无关)。
2. 多态的存在要有3个必要条件：继承，方法重写，父类引用指向子类对象。
3. 父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了。

package cn.zjb.test;
/**
 * 测试多态性
 * @author 张坚波
 *
 */
public class TestPolymorphism {	
	public static void main(String[] args) {
		Animal1 a=new Animal1();
		a.eat();
		Animal1 d=new Dog1();
		d.eat(); //多态
//		d.shout(); //错误的，编译器认为d是动物类的对象
		Animal1 c=new Cat1();
		c.eat(); //多态
		
		//成员变量没有多态性
		System.out.println(a.num);
		System.out.println(d.num);
		System.out.println(c.num);
	}
}

class Animal1{
	int num=1;
	void eat() {
		System.out.println("动物吃食物");
	}
}

class Dog1 extends Animal1{
	int num=2;
	@Override
	void eat() {
		System.out.println("狗吃骨头");
	}
	void shout(){
		System.out.println("汪汪汪");
	}
}

class Cat1 extends Animal1{
	int num=3;
	@Override
	void eat() {
		System.out.println("猫吃鱼");
	}
}

运行结果如下：

由此，我们可以看出多态的主要优势是提高了代码的可扩展性，符合开闭原则。但是多态也有弊端，就是无法调用子类特有的功能，比如，我不能使用父类的引用变量调用Dog类特有的方法。

开闭原则(Open-Closed Principle)就是让设计的系统对扩展开放，对修改封闭。

· 对扩展开放：
就是指，应对需求变化要灵活。 要增加新功能时，不需要修改已有的代码，增加新代码即可。

· 对修改关闭：

就是指，核心部分经过精心设计后，不再因为需求变化而改变。 在实际开发中，我们无法完全做到，但应尽量遵守开闭原则。

十. 对象的转型

对象的转型（casting）分为两种：

1. 父类引用指向子类对象，我们称这个过程为向上转型，属于自动类型转换。

2. 向上转型后的父类引用变量只能调用它编译类型的方法，不能调用它运行时类型的方法。这时，我们就需要进行类型的强制转换，我们称之为向下转型!

其中，对象的向下转型是不安全的，可能出错，因为动物可以是狗，但不一定是狗。如果向下转型错误，这种错误编译时可以通过，但是运行时是会报错的！

对象的向下转型的写法和强制类型转换的写法异曲同工：

(子类)对象名；

比方说上个程序中的狗类中的shout方法我想调用就要向下转型：

Animal1 d=new Dog1();
Dog1 dog=(Dog1) d;
dog.shout();

十一. final关键字

final关键字的三个用法：

1. 修饰变量: 被修饰的变量不可改变（相当于变成了常量）。一旦赋了初值，就不能被重新赋值。

2. 修饰方法：该方法不可被子类重写。但是可以被重载!

3. 修饰类: 修饰的类不能被继承。比如：Math、String等。

package cn.zjb.test;
/**
 * 测试final关键字
 * @author 张坚波
 *
 */
public class TestFinal {
	static final void method() {
		System.out.println("ha");
	}
	
	static final void method(int num) {
		System.out.println(num);
	}
	
	//没加final修饰
	static void method(int num1,int num2) {
		System.out.println(num1+""+num2);
	}
	public static void main(String[] args) {
		method();
		method(1);
		method(1,1);
	}
}

运行结果如下：

总结：