Java12--异常+访问控制符+抽象类

1 异常

1.1 概述

用来封装错误信息的对象。

组成结构：类型，提示，行号。

1.2 异常的继承结构

Throwable - 顶级父类

-- Error：系统错误，无法修复

-- Exception：可修复的错误

--RunTimeException

--ClassCastException

--ClassNotFoundException

1.3 异常处理

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

当调用了一个抛出异常的方法时，调用位置可以不做处理继续向上抛出也可以捕获异常。

1、捕获方式：

try{

    需要捕获的代码

}catch(异常类型  异常名){

    处理方案

}

2、抛出方式：

在会发生异常的方法上添加代码：throws 异常类型

例如： public static void main(String[] args) throws Exception{

1.4 测试

接收键盘输入的两个数字并做除法运算

package cn.tedu.exception;

import java.util.Scanner;

//测试异常的发生和解决

public class Test6_Exception {

//     接收键盘输入的两个整数并做除法运算

    public static void main(String[] args) {

//1，捕获异常：把可能发生异常的代码放在try里，

//当异常发生时会被catch住并执行catch中的代码执行异常处理的代码

       try {

           int a = new Scanner(System.in).nextInt();

           int b = new Scanner(System.in).nextInt();

           System.out.println(a/b);

       } catch (Exception e) {

           //提出解决方案

           System.out.println("您输入的两次整数有误！");
       }
    }
}

2 访问控制符

用来控制一个类，或者类中的成员的访问范围。

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

3 抽象类

3.1 概念

Java中可以定义没有方法体的方法，该方法由其子类来具体的实现。该没有方法体的方法我们称之为抽象方法，含有抽象方法的类我们称之为抽象类。

抽象类可以理解为是一个只有方法声明没有方法体的特殊类。

举例：水果，东西。。

修饰符 abstract 返回值 方法名(参数列表);
class A{
       public void eat(){//声明一样，可以提取

              syso("eat...B")    }
}
class B{
       public void eat(){//声明一样，可以提取
       syso("eat。。。A")   }
}            
abstract class C{
              public abstract void eat();
}

3.2 特点

1、 通过java关键字abstract实现

2、 可以修饰方法或者类

3、 抽象类中可以没有抽象方法（由子类去实现）

4、 如果类中有抽象方法，那该类必须定义为一个抽象类

5、 子类继承了抽象类以后，要么还是一个抽象类，要么就把所有抽象方法都重写

6、 多用于多态中

7、 抽象类不可以被实例化

3.3 入门案例

package day009;

public class Test1_Animal {
       public void eat(){
              System.out.println("吃饭饭");
       }
}

/*

 * 每种动物都需要吃，

 * 发现了，方法声明都一样，只是方法体不一样

 *

class Dog extends Test1_Animal{

       public void eat(){

              System.out.println("狗吃肉");

       }
}
class Cat extends Test1_Animal{

       public void eat(){

              System.out.println("猫吃鱼");

       }

}*/

//上面的eat()声明都一样，就是方法体不一样，那就只抽取方法声明部分。

//The type Animal must be an abstract class to define abstract methods

 abstract class Animal extends Object{

        //This method requires a body instead of a semicolon

       public abstract  void eat();

}
 //继承抽象类，并实现抽象方法

//The type Dog must implement the inherited abstract method Animal.eat()

abstract class Dog extends Animal{

     //可以实现抽象方法，也可以子类再变成一个抽象类

}
class Cat extends Animal{

       public void eat() {

              System.out.println("猫吃鱼");

       }      
}

3.4 抽象类的用法

3.4.1 构造函数

抽象类也有构造方法，但是不能本身实例化。

那抽象类的构造函数有啥用？一般用于给子类实例化。

package day009;
//抽象类的构造方法
public class Test2_Animal2 {
}
abstract class Animal2{
       //抽象类可以有构造方法，但是无法实例化

       //用于子类实例化

       public Animal2(){

              System.out.println("fu..Animal2()");
       }
}

class Zi2 extends Animal2{

}
class TestAnimal2{

       public static void main(String[] args) {

//           Animal2 a2 = new Animal2();//抽象类无法实例化   

//           Zi2 z=new Zi2();//创建子类实例化对象
              Animal2 a2 = new Zi2();//抽象类多用于多态    
       }
}

3.4.2 抽象类的成员变量

既可以有变量，也可以有常量。

package day009;
//成员变量
public class Test3_Animal3 {
}
abstract class Animal3{
       //String name;  //1
       //String name="大黄";  //2
       private String name="大黄";  //3
       public final int age=10;
       //3.1如果是私有变量想要取值，就提供getXxx()
       public String getName(){
              return name;
       }
}
class Zi3 extends Animal3{
}
class Test3Demo{

       public static void main(String[] args) {

              Animal3 a = new Zi3();//抽象类多用于多态

              //System.out.println(a.name());  //1或者2

              System.out.println(a.getName());  //3

              System.out.println(a.age);
       }

}

3.4.3 抽象类的成员方法

抽象类里，既可以有普通方法，有可以有抽象方法。

package day009;
//成员方法
public class Test4_Animal4{
}
abstract class Animal4{

       //抽象类中的普通方法

       public void speek(){

              System.out.println("fu...speak()");

       }

       //抽象类里的抽象方法

       public abstract void study();

}
class Zi4 extends Animal4{
       //重写抽象方法
       public void study(){
              System.out.println("zi...study()");
       }
}

class Zi4Test{
       public static void main(String[] args) {

              Zi4 z= new Zi4();

              z.speek();//fu...speak()

              z.study();//zi...study()
       }
}

3.5 分析案例

具体事物：培优班老师， 高手班老师

共性：备课，讲课

package day009;
public class Test5_Teacher {
}
abstract class Teacher{

       private String name;

       private int age;

       public void setName(String name){

              this.name=name;

       }

       public void setAge(int age){

              this.age=age;

       }

       public String getName(){

              return name;

       }

       public int getAge(){

              return age;

       }

       public abstract void teach();

       public void print(){

              System.out.println(name+"........"+age);

       }

}

class CgbTeacher extends Teacher{

       public void teach() {

              System.out.println("主打互联网架构的讲解");

       }

}

class ActTeacher extends Teacher{

       public void teach() {

              System.out.println("主打高薪冲刺");

       }

}

 

class Test5Demo{

       public static void main(String[] args) {

              CgbTeacher ct=new CgbTeacher();

              ct.teach();ct.setName("陈子枢");ct.setAge(20);

              ct.print();

             

             

              ActTeacher at=new ActTeacher();

              at.teach();

              at.setAge(30);

              at.setName("大佬");

              at.print();

             

              Teacher t = new CgbTeacher();

              t.teach();

              t.setName("jack");

              t.setAge(10);

              t.print();

       }

}