4 Day09--面向对象4

最新推荐文章于 2021-10-21 18:56:56 发布

abu1216

最新推荐文章于 2021-10-21 18:56:56 发布

阅读量135

点赞数

本文链接：https://blog.csdn.net/abu1216/article/details/110346570

版权

4.1 异常

4.1.2 异常的继承结构

Throwable - 顶级父类

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

-- Exception：可修复的错误

--RunTimeException

--ClassCastException

--ClassNotFoundException

4.1.3 异常处理

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

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

1、捕获方式：

try{

需要捕获的代码

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

处理方案

}

2、抛出方式：

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

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

4.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	√	√	√	√
protected	√	√	√
default	√	√
private	√

4.3 抽象类

4.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();

}

4.3.2 特点

1、通过java关键字abstract实现

2、可以修饰方法或者类

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

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

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

6、多用于多态中

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

4.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("猫吃鱼");

}

4.4 抽象类的用法

4.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();//抽象类多用于多态

}

4.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);

}

4.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()

}

4.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();

}

package cn.tedu.oop;
//描述高手班老师
public class ActTeacher extends Teacher{
   @Override
   public void ready() {
       System.out.println("高手班老师正在备课");
   };
   @Override
   public void teach() {
       System.out.println("高手班老师正在讲课");
   };
}

package cn.tedu.oop;
//描述培优班老师事物
public class CgbTeacher extends Teacher{
   @Override
   public void ready() {
       System.out.println("培优班老师正在备课");
   };
   @Override
   public void teach() {
       System.out.println("培优班老师正在讲课");
   };
}

package cn.tedu.oop;
//把子类的共性功能提取出来，形成父类
/*在父类中，可以不提供方法体，变成抽象方法，类里有抽象方法，这个类
* 变成抽象类，少写了很多代码，提高开发效率
* 抽象类的体现就是程序优化的结果
* */
abstract public class Teacher {
//备课/讲课

   //可以把父类的方法体给优化掉
   /*
   * 因为子类提供的方法体有点多余，
   * 子类继承后需要重写
   * */
       abstract public void ready();

       abstract public void teach();
}

package cn.tedu.oop;

import java.util.Scanner;

public class Test1_Exception {

   public static void main(String[] args){
       //method();//暴露异常
       try {
           method2();//异常抛出
       } catch (Exception e) {
           System.out.println("运算异常");
       }

   }
   //在方法声明上添加throws异常类型
   public static void method2() throws Exception{//多态
       //接收键盘输入的两个整数
       int a=new Scanner(System.in).nextInt();
       int b=new Scanner(System.in).nextInt();
       //做除法运算
       System.out.println(a/b);

   }

   //暴露异常
   public static void method() {
       //接收键盘输入的两个整数
       int a=new Scanner(System.in).nextInt();
       int b=new Scanner(System.in).nextInt();
       //做除法运算
       System.out.println(a/b);

   }
}

package cn.tedu.oop;
//测试抽象类
//抽象类不能被实例化（new ）
//抽象类多用于多态中
public class Test2_Abstract {

   public static void main(String[] args) {
       //创建多态对象
       Animal a=new Cat();//父类引用指向子类对象
       //编译看左边--功能向父类看齐，父类就是标准
       //运行看右边--结果要看子类是怎么干的--针对方法重写提的
       a.eat();//猫吃鱼
       a.sleep();//呼呼大睡

}

//普通类，普通方法
//如果类里包含抽象方法，这个类就是抽象类
abstract class Animal{
   //通过abstract关键字来描述抽象
   //抽象方法只有方法声明没有方法体
   abstract public void eat();
public void sleep() {
   System.out.println("呼呼大睡");
};
}

//子类继承抽象类以后，
//1.要么是一个抽象类
//2.要么把所有抽象方法都重写
abstract class Dog extends Animal{

}

class Cat extends Animal{
   @Override
   public void eat() {
       System.out.println("猫吃鱼");
   };
}

package cn.tedu.oop;
//测试抽象类使用构造方法
public class Test3_Useabstract {

public static void main(String[] args) {
// 测试

       //触发子类的构造方法
       new Dog2();

   }

}
//抽象类
abstract class Animal2{
   //抽象类里可以有构造方法
   //不是为了让自己new 而是为了让子类new
   //构造方法
   public Animal2() {
       System.out.println("父类的构造方法");
   }
}

class Dog2 extends Animal2{
   public Dog2() {
       //隐藏着super()--会去找父类的无参构造
       super();
       //有一个默认的无参构造
       System.out.println("子类的构造方法");
   }

}

package cn.tedu.oop;
//测试抽象类使用成员变量
//抽象类里可以有变量也可以有常量
public class Test4_UseAbstract2 {

public static void main(String[] args) {
//测试变量能否被继承

       Animal3 a=new Dog3();
       a.name="二哈";
       System.out.println(a.name);//二哈
       System.out.println(a.MAX_VALUE);//获取值127
   }

}
//抽象类成员变量
abstract class Animal3{
   //抽象类中可以提供变量
   String name="大黄";
   //抽象类中可以提供常量吗？
   //常量是不可以修改的
   public static final byte MAX_VALUE =127;
}
class Dog3 extends Animal3{

}

package cn.tedu.oop;
//测试抽象类使用成员方法
//抽象类是一个特殊的类
//非常灵活，特殊在类里有抽象方法，也可以有普通方法
public class Test5_Useabstract3 {

   public static void main(String[] args) {
       Animal4 a=new Dog4();
       a.sleep();//普通方法--重写前用父类的，重写后用子类的
       a.eat();//抽象方法--用了父类的方法声明，子类的方法体
       a.game();//抽象方法--用了父类的方法声明，子类的方法体

}

}
//如果类里都是普通方法，这个类仍然被修饰成了抽象类-抽象类不能实例化（new）
abstract class Animal4{
   //普通方法
   public void sleep() {
       System.out.println("sleep()....");
   }
   abstract public void eat();
   //抽象方法
   abstract public void game();
}
//抽象类的子类，有两条路：
//1.要么是抽象类，要么把所有的抽象方法都重写
//2.继承过来的普通方法，需要就重写，不需要就不重写
//abstract class Dog4 extends Animal4{
//
//}

class Dog4 extends Animal4{
   @Override
   public void sleep() {
       System.out.println("sleep()1....");
   }
   @Override
   public void eat() {
       System.out.println("吃肉");
   };
   @Override
   public void game() {
       System.out.println("玩球");
   };
}

//抽象类的子类，可以还是一个抽象类
abstract class Cat4 extends Animal4{
//Animal4里面有两个抽象方法，你只重写一部分的话，就是说明还包含着没重写
//的抽象方法，还是一个抽象类
}

package cn.tedu.oop;
//程序设计
/*
* 具体事物：培优班老师，高手班老师
* 共性：备课/讲课
* 测试：创建多态对象测试
*
* 设计思路：
* 1.有两个事物需要描述，就应该对应程序中的两个类
* 2.每各类都需要提供共性的功能：备课/讲课
* 3.把共性的功能，提取出来，形成父类
* 4.需要考虑，把父类进行设计优化，可以把父类修饰成抽象类
* */
public class Test6_Design {

   public static void main(String[] args) {
       Teacher t=new CgbTeacher();
       t.ready();//培优班老师正在备课
       //使用了父类的方法声明，使用了子类的方法体
       t.teach();//培优班老师正在讲课

       Teacher t2=new ActTeacher();
       t2.ready();//高手班老师正在备课
       t2.teach();//高手班老师正在讲课
   }

}