Java带你去看流浪世界！（十）

继承（封装，多态）

实现代码重用的重要手段之一，也是面向对象的三大特性之一。

1.理解继承的作用

父类方法不能重写，因为子类是继承父类，当改变父类的时候子类也要随之改变。

1.继承是面向对象软件技术当中的一个概念，与多态，封装共为面向对象的三个基本特征。继承可以使得子类具有父类的属性和方法或者重新定义，追加属性和方法。

2.继承是Java中实现代码重用的重要手段

3 .继承是面向对象的三大特性之一。

4.在两个类实现了继承之后，会产生子类和父类的概念，而子类可以拥有父类中的属性和方法，子类还可以对这些方法进行重写。

2.掌握继承的基本使用

/**
 *   Dog类和Cat类都是宠物的一种
 *   Dog（子类）	[is	a]	Pet(父类)
 *   Cat		[is	a]	Pet
 *
 *   将子类中的公有代码/重复代码，抽取到父类
 */

//拥有了继承关系之后，子类就可以拥有父类中的属性和方法
Cat extend Pet//子继承了父
    
    //this 表示当前对象，可以调用自己的成员属性和成员方法
    //this.xxxx 能够调用Cat子类中没有调用的当前方法，因为要从Pet父类中继承而来的。

1.将多个类（子类）抽取公共代码（属性，方法）到父类中。

子类	is	a	父类

public class Pet{
	//公共代码
}

2.使用子类去继承父类，即可拥有父类中的公共代码

public class Dog extends Pet{
    //自己特有的
    //继承了父类中公共的
}

继承的注意事项

1.子类不是无限继承父类中的内容，它只能继承父类中非私有（非private修饰）的代码，也不能继承构造方法，也不能继承不同包中，默认修饰的内容。

1.只能继承父类中非私有（非private修饰）的代码: private修饰的内容是私有的，只能在本类中使用。

2.也不能继承构造方法：构造方法是用来初始化对象（对象创建），它是给父类创建对象用的。

3.也不能继承不同包中，默认修饰的内容:

修饰符\作用域	本类	同包	子类	任何地方（同一个项目）
private	√
默认的	√	√
protected	√	√	√
public	√	√	√	√

2.子类和父类之间要有is a 的关系，不要卵用继承。

3.掌握super关键字的使用

1.类似于this，this表示当前类的某个对象，谁在调用谁就是当前对象

1.this可以调用自己的属性（this.xxx），自己的方法（this.xxx），自己的构造（this（））。

2.super表示当前类的父类的对象。

1.super可以调用父类的属性（super.xxx），父类的方法（super.xxx（）），父类的构造（super（））。

3.this和super在构造中调用其他构造时，只能出现在有效代码的第一行。

4.子类继承父类之后，子类的构造方法中会自动添加父类构造的调用代码。

public Dog extends Pet{
public Dog(){
    //特别的，特殊的调用
    super();
}

4.继承之后的加载顺序

父类静态代码块，父类构造代码块，父类的构造方法，子类的静态代码块，子类的构造代码块，子类的构造方法

父类静态代码块 -> 子类静态代码看 ->【父类构造代码块 -> 父类构造方法 -> 子类构造代码块 -> 子类构造方法】

方法重写

若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。 如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。

（修饰符高低：private < 默认修饰符 < public）

1.掌握方法重写

方法重写：在子类继承了父类的信息之后，如果有的方法不是太适合/强大，可以根据子类的需求进行方法重新编写。当父类的权限为private时，子类无法继承。

**关于方法重写的一些特性**：

1.发生方法重写的两个方法返回值、方法名、参数列表必须完全一致(子类重写父类的方法)

2.子类抛出的异常下不能超过父类相应方法抛出的异常(子类异常不能大于父类异常)

3.子类方法的访问级别不能低于父类相应方法的访问级别(子类访问级别不能低于父类访问级别)

根据2，3条可以确定第一条，子类重写父类方法的返回值类型不能大于父类方法的返回值类型，即是说子类方法的返回值必须和父类方法的返回值相同或是其子类。

方法重写的规则（何种情况下，认定它为方法重写）：

1.方法名相同，参数列表相同，返回值类型相同或者其子类，访问修饰符不能严于父类，（不能抛出比父类更大和更多的异常）。

public class Pet{
    public void show(){
    	syso(name);
		syso(health);
		syso(love);
	}
}

//子类重写父类的方法
public class Dog extends Pet{
    @Override
     //访问修饰符不能严于父类
    pubilc voic show(){
   		//重写后的代码，子类重写后的方法
        //子类重写方法时，如果对原有方法添加额外功能，则可以利用父类中部分代码进行复用
        //子类重写方法时，若果是对原有方法直接颠覆，那么父类中的该方法则失去了复用的价值
        super.show();//增强，优化，调用父类的方法
        syso(xxx);
	}
}
 //注解：JDK1.5之后诞生的特性，用来帮助简化配置和简化检验等。
@Override （推翻）//检验是否是合格的方法重写
@Deprecated  (不赞成）//使用作废，使用过期，标注某个方法，未来不定时时间内可能会行进移除，不推荐使用

当子类重写了父类的方法之后，执行此方法时，会执行子类重写后的方法。

疑问：

1.既然子类都要重新编写一次方法，何必再父类中提供此方法？（多态）

以目前的眼光：子类在重写方法时，还可以调用父类原有的代码内容。

2.子类重写方法时，如果是对原有方法进行添加额外功能，则可以利用父类中部分代码进行复用

3.子类重写方法时，如果是对原有方法直接颠覆，那么父类中的该方法则失去了复用的价值

2.掌握方法重写和重载的区别

方法重写：在子类中，出现的和父类的方法名相同，参数列表也相同，返回值类型相同或为其子类，访问权限修饰不能严于父类，不能抛出父类更多更大的异常。

方法重载：在同一个类中，出现的方法名相同，参数列表不同的情况。与方法的返回值类型和访问修饰符无关。

Arrays.toString（）；

System.out.print（）；

//方法重载
/** 方法重载的具体规范：
 *   一.方法名一定要相同。
 *   二.方法的参数表必须不同，包括参数的类型或个数，以此区分不同的方法体。
 *   1.如果参数个数不同，就不管它的参数类型了！
 *   2.如果参数个数相同，那么参数的类型必须不同。
 *   三.方法的返回类型、修饰符可以相同，也可不同。
 */
public void method1(){
    
}
public int method1(int a){
    
}
public double method1(double a){
    
}

3.了解Object（目标，物体）类

在Java中是单根继承的，它有且仅有一个父类。

Object类它是Java中最顶级的类，我们一般称它为超类。所有的Java一定是直接或者间接继承自Object。

1.如果你定义一个类，它默认就继承了Object类

2.如果你蛋蛋定义了一个父类和子类，子类继承自父类，父类继承自Object类

我们在以前调用方法时，应该见到了很多莫名其妙的方法，我们在学了继承之后知道，如果子类不定义方法，却还可以使用，说明此方法来自于(Object的类)他的父类。我们见到的这些莫名其妙的方法就是继承自Object类。

在Object中有一些经常被使用的方法：

boolean epuals（Object 阿obj）；//在判断字符串内容时

public boolean equals(object obj){
    return (this == obj);//利用 == 比较内容
}

String类对此方法进行了重写，所以才可以进行字符串内容的比较。

String toString（Object obj)； //自数组转换为数组内容字符串时。

public String toString() {
    // getClass().getName() 获取类名     类名@7831231    例如：Student@787822
	return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
Student student = new Strdent();
//当你调用输出对象是，默认是调用的对象是toString（）；

重写equals方法

字符串比较内容。

// Eclipse快捷键 ： 快速重写equals  Alt+Shift + S  ->  h
	// 重写了Object类中的equals方法
	// stu1.equals(stu2)
	// stu1：this
	// stu2：obj
	@Override
	public boolean equals(Object obj) {
		// 通过==比较两者    因为是引用数据类型 所以比较地址值  地址值相同是同一个对象 
		if (this == obj) 
			return true; // 同一个对象 内容一致
		// 判断obj是否为空
		if (obj == null) 
			return false; // stu1能直接调用方法说明stu1不为空   而stu2为null  两者肯定不相同
		// 判断是否是相同类型  
		if (getClass() != obj.getClass())
			return false; // 例如：狗对象和学生对象  肯定内容不一样 没必要比较
		// 向下转型(强转)  int num = (int)10.1;
		// 将stu2转换为Student类型的对象
		Student other = (Student) obj;
		// 比较stu1的名字是否为空 this.name
		if (name == null) {
			// 如果为空 判断stu2的名字是否为空  如果stu2的名字不是null 则无需比较了
			if (other.name != null)
				return false;
			// 如果name都不为空  那么通过字符串的equals方法来直接比较名字的内容是否相同
		} else if (!name.equals(other.name))
			return false; // 如果name不一样 其他属性不用再比了
		
		// 比较学生编号  如果学生编号不一致 返回false
		if (stuNo != other.stuNo)
			return false;
		// 如果最终走到这里 说明他们的两个属性内容确实完全一致 返回true
		return true;
	}

String字符串其实本质（底层）就是一个字符数组。

他重写equals（）方法就是在比较字符数组的内容。

public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

equals和==的区别

默认情况下，epuals方法和==是完全一样的。

但是String重写了equals方法，可以比较字符串的内容了。

== 在比较引用数据类型的时候，比较的是栈中的地址值。 stu2 == stu3(x)

==它比较基本数据类型比较的是内容。 10 == 12 （√）