JAVA_Basis -- 4. 3 面向对象

1 异常

1.1 概念：

程序在运行的过程之中，出现导致程序无法正常运行的问题，Java中的异常指的是用来封装导致程序无法正常运行的错误信息的类，组成结构是：类型+提示符+行号

1.2 分类：

Throwable：Java中任何异常类的父类，代表了所有的异常类所具有的共同属性。
Error：（不可查异常，不要求强制处理）指的是程序发生了严重的系统不可处理的问题。
Exception：（可查异常，必须处理）指的是程序发生了系统可以处理的异常问题。
RuntimeException：指的是运行时异常，程序可以选择捕获处理，也可以不处理。
IOException：指的是非运行时异常，这类异常时必须进行处理的异常。

1.3 异常处理

程序中遇到了异常，通常有两种处理方式：捕获和向上抛出

1.3.1 捕获异常：

try-catch

try{
    需要捕获的异常代码
}catch(异常类型 异常名字){
    处理方式
}

try-catch-finally

try{

    需要捕获的异常代码
}catch(异常类型 异常名字){
    处理方式
}finally{
    代码块（用于回收资源）
}

案例

	package com.mtingcat.javabasis.object.exception;
	
	import java.util.Scanner;
	
	/**
	 * 测试异常
	 * @author MTing
	 *
	 */
	public class DomeException {
		public static void main(String[] args) {
			
			System.out.println("Input your number:");
			/**
			 * 把可能发生异常的代码放到try代码块里面，一旦
			 * 发生异常就会执行catch中的代码。
			 */
			try {
				@SuppressWarnings("resource")
				int a = new Scanner(System.in).nextInt();
				@SuppressWarnings("resource")
				int b = new Scanner(System.in).nextInt();
				System.out.println("a / b = " + a/b);
			} catch (Exception e) {	
				System.out.println("Input error");
			}
			System.out.println("end");
		}
	
	}

	package com.mtingcat.javabasis.object.exception;
	
	import java.util.Scanner;
	
	/**
	 * 测试异常
	 * @author MTing
	 *
	 */
	public class DomeException {
		public static void main(String[] args) {
			
			System.out.println("Input your number:");
			/**
			 * 把可能发生异常的代码放到try代码块里面，一旦
			 * 发生异常就会执行catch中的代码。
			 */
			try {
				@SuppressWarnings("resource")
				int a = new Scanner(System.in).nextInt();
				@SuppressWarnings("resource")
				int b = new Scanner(System.in).nextInt();
				System.out.println("a / b = " + a/b);
			} catch (Exception e) {	
				System.out.println("Input error");
			}finally {  //用于回收资源
				System.out.println("finally");
			}
			System.out.println("end");
		}
	
	}

2 访问控制符

用来控制一个类或者类中的成员的访问范围。
public：公共访问权限，被这个关键字修饰的成员或者类可以被其他所有的类访问。
protected：子类访问权限，被这个关键字修饰的成员或者类可以被同包中的类访问，也可以被不同包中的子类访问。
default：包访问权限：被这个关键字修饰（无访问修饰关键字）的成员或者类可以被相同包下的其他类访问。
private：当前类访问权限，被这个关键字修饰的成员或者类只能在当前类的内部被访问。

	类	包	子类	任意类
public	√	√	√	√
protected	√	√	√
default	√	√
private	√

3 抽象类

3.1 概念

Java中可以定义没有方法体的方法，该方法由其子类来具体的实现。该没有方法体的方法我们称之为抽象方法，含有抽象方法的类我们称之为抽象类，抽象类可以理解为是一个只有方法声明没有方法体的特殊类，抽象类是为了继承，Java是单继承，意味着一个父类中可以有多个子类，但是一个子类只能有一个父类 抽象类中的抽象方法是为了子类在继承抽象类时不同的行为可以被不同的子类进行分别实现。

修饰符 abstract 返回值 方法名(参数列表);

3.2 特点

① 通过java关键字abstract实现
② 可以修饰方法或者类
③ 抽象类中可以没有抽象方法（由子类去实现）
④ 如果类中有抽象方法，那该类必须定义为一个抽象类
⑤ 子类继承了抽象类以后，要么还是一个抽象类，要么就把所有抽象方法都重写
⑥ 多用于多态中
⑦ 抽象类不可以被实例化

3.3 案例

3.1 设计思路：

① 将所有子类的共性属性和方法抽取到父类中 ----抽共性。
② 所有子类的行为都一样，设计成不同方法。
③ 所有子类的行为都不一样，设计成抽象方法。

3.2 规则

① 抽象类也有构造方法，但是不能本身实例化。
② 既可以有变量，也可以有常量。
③ 抽象类里，既可以有普通方法，有可以有抽象方法。

抽象类

package com.mtingcat.javabasis.abstract11;
/**
 * 抽象类
 * @author MTing
 *
 */
public abstract class abstractAnimals {
	//抽象类中的普通属性
	String name;
	//抽象类中的抽象方法,一个类中如果有抽象方法，那么这个类必须是抽象类，子类中必须重写
	public abstract String eat();
	public abstract String sleep();
	//抽象类中的普通方法
	public String do01(){
		return "抽象类中的普通方法do01()";
	}

}

子类

package com.mtingcat.javabasis.abstract11;

public class extendsAnimals extends abstractAnimals{
	
	String sex;
	int age;
	public String run(){
		return "子类添加的方法run()";
	}
	@Override
	public String eat() {
		return "重写了抽象类抽象方法eat()";
	}

	@Override
	public String sleep() {
		return "重写了抽象类抽象方法sleep()";
	}

}

普通类

package com.mtingcat.javabasis.abstract11;

public class Cat {
	public static void main(String[] args) {
		extendsAnimals mtingCat = new extendsAnimals();
		System.out.println(mtingCat.eat());
		System.out.println(mtingCat.sleep());
		System.out.println(mtingCat.do01());
		mtingCat.name = "MTingCat";
		mtingCat.age = 10;
		mtingCat.sex = "boy";
		System.out.println(mtingCat.name+","+mtingCat.age+","+mtingCat.sex);
	}

}

3.4 抽象类的意义

① 封装了子类所有的方法和行为，提高代码的可用性。
② 为子类提供一个统一的造型方式–向上造型。
③ 可以包含抽象方法，为子类提供统一的入口，子类的具体实现不同，但是入口一致。

4 成员内部类

类中套类，外面的类称之为Outer外部类，里面的类称之为Inner内部类。

内部类通常只服务于外部类，对外不具备可见性。

内部类对象通常需要在外部类中被创建

内部类可以直接访问外部类的成员(包含私有的)，内部类有一个隐式的引用指向创建它的外部类对象外部类名.this.

5 匿名内部类

若想创建一个类(派生类)的对象，并且该对象只被创建一次，此时该类不必命名，称之为匿名内部类。

内部类中访问外面的变量，该变量jdk1.7(包含)以前必须是final的

6 接口

6.1 接口的概述

ava里面由于不允许多重继承，所以如果要实现多个类的功能，则可以通过实现多个接口来实现。
Java接口和Java抽象类代表的就是抽象类型，就是我们需要提出的抽象层的具体表现。OOP面向对象的编程，如果要提高程序的复用率，增加程序的可维护性，可扩展性，就必须是面向接口的编程，面向抽象的编程，正确地使用接口、抽象类这些太有用的抽象类型做为java结构层次上的顶层。

6.2 接口的形式

interface 接口名 {
    代码...
}

6.3 接口的特点

① 接口是一种规范，突破了java单继承的局现象，是抽象类的拓展。
② 通过interface关键字创建，通过implements关键字让子类实现。
③ 在接口中只能包含常量和抽象方法。
③ 接口不能被实例化，接口和接口之间可以实现，也可以多继承。
⑤ 接口需要被实现/继承，实现类/子类要实现接口就必须重写接口中的抽象方法。
⑥ 一个类可以时间多个接口，接口之间用逗号分隔，如果又继承又实现，应该是先继承后实现。
⑦ 接口提高了程序的功能扩展，降低了耦合性。

6.4 案例

package com.mtingcat.javabasis.interface10;
/**
 * 关于接口的入门案例
 * @author MTing
 *
 */
public class entryLevelDemo {
	@SuppressWarnings("static-access")
	public static void main(String[] args) {
		S s01 = new S();
		SSS s02 = new SSS();
		s01.name = "Tom";
		s01.id = 01;
		s01.work();
		System.out.println(s01.study());
		System.out.println("student:"+s01.name+"id:"+","+s01.id);
		System.out.println(s01.studyPlace+s01.studyGroup);
		System.out.println(s02.input());
		
		
		
	}
}

class SSS extends S implements C,Person {
	
	public String input(){
		return "继承的同时实现";
		
	}
}

class S implements Student,C{
	
	String name;
	Integer id;

	@Override
	public String study() {
		return "实现类重写了接口方法student（）";
	}

	@Override
	public void work() {
		System.out.println("实现类重写了接口方法work（）");
	}

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

/**
 * 接口Student继承了接口Person和Behave，体现了接口多继承的特性
 * @author MTing
 *
 */
interface Student extends Person,Behave{
	public static final String studyPlace = "school";
	String studyGroup = "class";
	
}

interface Behave{
	public abstract String study();
	void work();
}


interface Person{	
	public abstract void show();
}
interface C{}

6.5 接口的用法

6.5.1 构造方法

接口里面没有构造方法，在创建实现类的对象时默认是super()，调用默认的是Object()无参构造。

interface Person{	
	public abstract void show();
}

6.5.2 成员变量

接口里没有成员变量，都是常量。所以，你定义一个变量没有写修饰符时，默认会加上public static final

interface Student extends Person,Behave{
	public static final String studyPlace = "school";
	String studyGroup = "class";
	
}

6.5.3 接口的成员方法

接口里的方法，默认就都是抽象的，如果你不写明是abstract的，那会自动补齐。
例如：public abstract void save

interface Behave{
	public abstract String study();
	void work();
}

6.5.4 接口的复杂用法

Java中单继承的局限性通过接口可以解决。
接口可以多继承也可以多实现，甚至可以继承的同时多实现。

class SSS extends S implements C,Person {
	
	public String input(){
		return "继承的同时实现";
		
	}
}

interface Student extends Person,Behave{
	public static final String studyPlace = "school";
	String studyGroup = "class";
	
}

6.6 总结

1 类和类的关系：继承 extends / 单继承 / 单根继承

– 继承的意义：为了提高代码的复用性，减少了代码的编写提高开发效率。
– 方法重写的意义：在不修改父类源码的前提下，在子类中重写业务，从此使用的就是重写后的功能。
– 要求子类的方法声明和父类一样，只要改方法体。
– 有了继承有了重写就产生了多态，多态的意义：为了统一程序的调用标准，标准就是父类。
– 多态 也就是向上转型/向上造型。
– 向下造型的意义：很少用，相当于想要使用子类的特殊功能，还不如直接创建子类对象简单。
– class A extends B
– 其中，A和B都是类，A是子类，B是父类，A就拥有了B的所有功能(除了私有的和构造方法)
– 其他知识点：this 和super ，构造方法，各种代码块…

2 类和接口关系：实现implements / 单实现 / 多实现

– class A implements B,C
– 其中，A是实现类,B和C是接口
– 要求A 可以把 B 和C 接口里的所有 抽象方法 都重写掉，否则 A 就是抽象类
– 接口不能创建对象
– 接口里没有构造方法，接口里都是常量，接口里都是抽象方法

3 接口和接口关系：继承extends / 单继承 / 多继承

– 接口的多继承的关系，打破了java单继承的局限性
– interface A extends B,C
– 其中，A B C 都是接口，A是子接口，同时拥有B和C接口里的所有功能
– class AImpl implements A
– 要求AImpl需要重写A接口里的所有方法(是包含B和C接口的所有方法)，否则就是抽象类

4 接口和抽象类的区别！！！

– 相同点：都是抽象层，都不能实例化
– 不同点：
– 1、抽象类用abstract关键字描述，接口用interface
– 2、子类和抽象类之间是extends关系，实现类和接口之间是implements关系
– 3、抽象类中 可以 有构造方法 ，接口里 不能 出现 构造方法
– 4、抽象类里可以有 变量，接口里没有变量全都是静态的常量
– 5、接口里定义常量的语法：public static final String NAME=“jack”，会为变量自动拼接public static final
– 6、抽象类里 可以有普通方法 也可以有 抽象方法，接口都是抽象方法
– 7、抽象类和子类之间是继承关系，而且java中，只支持单继承
– 8、接口突破了java单继承的局限性，因为接口可以多继承也可以多实现，甚至可以继承的同时多实现
– 9、接口的复杂用法
– 多继承： interface A extends B,C 其中A是子接口，同时拥有自己的和BC的功能
– 多实现： class AImpl implements M,N,O,P 其中AImpl是实现类，需要同时重写MNOP的所有抽象方法，否则就是一个抽象类
– 继承的同时多实现： class AImpl extends Object implements M,N 一定是先继承后实现