面向对象——继承

本来是想接着封装一起发的，然后写到一半有事就耽搁了一下，再然后因为各种各样的事情就把这东西忘记了ヾ(´∀`o)+
今天既然想起来了就赶紧写完(>▽<)

面向对象的三大基本特征：封装（encapsulation）、继承（inheritance）、多态（polymorphism）

1、继承

继承可以实现父子关系以及代码的复用。
Java的继承通过extends关键字来实现，实现继承的类叫子类，被继承的类叫父类。
（ps：Java只支持单继承，即每个类只能有一个父类）
（ps的ps：Object是顶级父类，默认情况下父类都是Object，所以所有类都是Object的直接子类或间接子类）

1.1、继承的作用

1.描述类和类的关系；
2.降低类和类间的重复代码。

1.2、instanceof

instanceof关键字用来判断一个对象是否是指定类创建的对象。

//语法：
//	boolean flag = 对象 instanceof 类;
//示例：
Father father = new Father();
System.out.println(father instanceof Father);

1.3、方法的重写

public class Father {
	public String address="山西大同煤炭街01号";
	public int money=999999999;
	public String words="我是父类";
	// 私有属性不能被继承
	private String note="张大麻子还欠我100块";
	
	public void play() {
		System.out.println("打麻将");
	}
	// 私有方法不能被继承
	private void savePrivateMoney() {
		System.out.println("存私房钱");
	}
}

// 子类继承父类
public class Son extends Father {
	public String words="我是子类";
	public int girlNumber=1;
	public void code() {
		System.out.println("欢乐的写代码");
	}
	// 方法的重写
	// 前置条件：
	// 	1.两个类存在继承关系
	// 	2.父类中的方法是公共的
	@Override// 注解
	// 利用注解对方法进行重写
	public void play() {
		System.out.println("打篮球");
	}
}

执行

public class Test01 {

	public static void main(String[] args) {
		Father father = new Father();
		System.out.println(father.words);
		System.out.println(father.address);
		System.out.println(father.money);
		father.play();
		System.out.println("--------------------");
		Son son = new Son();
		System.out.println(son.words);
		System.out.println(son.address);
		System.out.println(son.money);
		son.play();
		// 子类除了从父类那继承的公共属性与公共方法外还能有自己的属性和方法
		System.out.println(son.girlNumber);
		son.code();
		
		System.out.println(father instanceof Father);
	}
}

1.3.1、重写的要求

1.子类的重写方法与父类的被重写方法，两者的名称与参数列表必须相同；
2.子类的重写方法的访问权限要大于等于父类的被重写方法（访问权限：public>protected>default>private）;
3.子类的重写方法的返回值必须是父类的被重写方法的返回值类型或该类型的子类；
4.子类的重写方法的异常不能比父类的被重写方法的多；
5.子类不能继承父类的构造函数，也不能重写，但是可以使用super关键字访问父类的构造函数（super.方法名()）。

public class Father {
	public String address="山西大同煤炭街01号";
	public int money=999999999;
	public Father() {
		System.out.println("Father的无参构造函数");
	}
	public Father(int i) {
		System.out.println("Father的无参构造函数"+i);
	}
}

public class Son extends Father {
	// super表示对当前对象的父类对象的一个引用，用于访问父类的属性、方法、构造方法.。
	// 调用父类构造函数的super只能放在子类的构造函数的第一行，且只能调用一次。
	// 不能同时存在super()和this()
	public int girlNumber=1;
	public Son() {
		// super();// 调用父类的无参构造函数
		super(99);// 调用父类的有参构造函数
		System.out.println("Son的无参构造函数");
	}
}

1.3.1、重写与重载

重写：
用于继承关系的父子类，不能用于同一个类；
用于更改父类中方法的行为或实现接口中的方法。
特点：
函数名相同，参数列表相同；
子类的返回值类型不能大于父类的返回值类型；
子类抛出的异常类型不能大于父类的异常类型；
子类的作用域不能小于父类的作用域；

重载：
用于同一个类；
用于为一个行为提供多种实现方式。
特点：
函数名相同，参数列表不同，与其他因素无关。

1.4、继承特性总结

1.Java只支持单继承与多层继承，不允许多重继承；
2.子类可以继承父类的非私有属性和私有方法；
3.子类可以拥有自己的属性和方法；
4.子类无法继承父类的构造函数；
5.继承要符合逻辑，不能单纯为了继承而继承，如：可以让学生继承人，但是不能由学生继承老师之类的。

2、final

final关键字修饰类，则该类不能被继承

public class Father {
	public String words="匿名对象的使用";
}


// final不能被继承但是可以继承别人
public final class Final extends Father{
	public String attention="final修饰的类没有子类";
}

final关键字修饰属性，则该类不能被修改
（1）常量必须初始化；
（2）基本数据类型，final修饰的值无法被修改；
（3）引用类型，final修饰的值的对象无法改变，但是对象内容可以修改。

final关键字修饰方法，则该类不能被重写
父类中的方法被final修饰后，该方法就无法再它的子类当中被重写。

final关键字修饰形参，则该类不能被修改

public class print(final String[] arr){
	//arr无法重新赋值
	//arr=null;
	for(int i=0;i<arr.length;i++){
		System.out.println(arr[i]);
	}
}

3、可见性

3.1、小结

（1）private修饰的成员只能在本类使用；
（2）public修饰的成员可以被所有类访问；
（3）protected修饰的成员可以被包中其他类访问，且位于不同包的子类也可以访问；
（4）default是默认修饰成员的关键字，可以被包中的其他类访问。

4、接口

Java只支持单继承，但是Java通过接口来拓展类的功能，来弥补单继承的缺点。

4.1、接口的定义

（1）关键字：interface
（2）接口中方法只有声明，没有定义
（3）接口中所有属性的默认修饰符是：public static final
（4）接口中所有方法的默认修饰符是：public abstract

public interface MyInterface1 {
	double ABC=2.3;
	void test();
	public abstract String print(int number);
}

// 实现接口就必须实现里面的类
public class MyClass1 implements MyInterface1 {

	@Override
	public void test() {
		System.out.println("MyClass1");

	}

	@Override
	public String print(int number) {
		return number+"";
	}
}

// 接口的实现
public class Test1 {

	public static void main(String[] args) {
		MyClass1 class1 = new MyClass1();
		class1.test();
		String print = class1.print(99);
		System.out.println(print);
		
		MyClass2 class2 = new MyClass2();
		class2.test();
		String print2 = class2.print(10);
		System.out.println(print2);
	}
}

接口可以说是一种特殊的抽象类，只包含常量和方法的定义，不包含变量和方法的实现。

4.2、接口的实现

接口的实现用关键字implements

4.2.1、单接口实现

//接口
public interface MyInterface1 {
	double ABC=2.3;
	void test();
	public abstract String print(int number);
}

// 实现接口就必须实现里面的类
public class MyClass1 implements MyInterface1 {

	@Override
	public void test() {
		System.out.println("MyClass1");

	}

	@Override
	public String print(int number) {
		return number+"";
	}
}

4.2.2、多接口实现

一个类实现多个接口，那么接口之间用逗号隔开

// 接口1
public interface MyInterface1 {
	void test1();
}
// 接口2
public interface MyInterface2 {
	void test2();
}


// 接口实现
public class MyClass implements MyInterface1,MyInterface2 {

	@Override
	public void test1() {
		// TODO Auto-generated method stub

	}

	@Override
	public void test2() {
		// TODO Auto-generated method stub

	}
}

4.3、接口的继承

接口支持多重继承，即一个接口可以有多个父接口

public interface Interface1 {
	void test1();
}
public interface Interface2 {
	void test2();
}
// Interface3接口拥有父接口的test1、test2以及自身的test3方法
public interface Interface3 extends Interface1,Interface2 {
	void test3();
}

4.4、接口的总结

（1）接口没有构造方法
（2）接口中定义的所有属性默认为：public static final，即静态常量
（3）接口中定义的所有方法默认为：public abstract，即抽象方法
（4）接口不能被实例化（原因：接口中定义的所有方法都是抽象的）
（5）类可以通过implements实现接口，一个类可以实现多个接口
（6）如果类没有实现接口的所有方法，那么这个类只能是抽象类
（7）在类中访问接口的属性，方法是：接口名.属性名

5、实例代码

// 接口
public interface Eraser {
	void clean();
}

// 父类
public class Pencil {
	public void write() {
		System.out.println("铅笔写字");
	}
}

// MyPencil是Pencil的子类实现接口Eraser
public class MyPencil extends Pencil implements Eraser {
	public void clean() {
		System.out.println("橡皮擦除写错的东西");
	}
}

// 测试
public class Test1 {
	public static void main(String[] args) {
		MyPencil myPencil = new MyPencil();
		myPencil.write();
		myPencil.clean();
	}
}

结果：
铅笔写字
橡皮擦除写错的东西

ここは最后だ(๑•̀ㅂ•́)و✧