8.JAVA面向对象之多态

最新推荐文章于 2024-07-18 04:10:26 发布

太彧

最新推荐文章于 2024-07-18 04:10:26 发布

阅读量167

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_56027329/article/details/129972455

版权

一、多态

1.1概述

多态指同一个实体同时具有多种形式。它是面向对象程序设计（OOP）的一个重要特征。

主要是指同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。

好处是可以把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。

例如：水，在不同时刻可以有多种形态，包括水蒸气，冰，水。

1.2特点

1、多态的前提是继承。

2、要有方法的重写。

3、父类引用指向子类对象,如：Animal a = new Dog(); -- 小到大，向上转型。

4、多态中，编译看左边，运行看右边。

package cn.tedu.oop;
//测试  多态
public class Test1 {
	public static void main(String[] args) {
		new dog().eat();
		Animal a = new dog();//通用性/统一调用标准
		a.eat();//父类有才能用，子类有父类没有，不能调用
//		Animal.eat();//类名调用时必须确保方法是静态的
		//多态不支持用子类功能，只能使用父类的功能，子类很少有扩展功能
//		System.out.println(a.name);
	}
}
//提取子类的所有共性代码，提高复用性
class Animal{
	public void eat() {
		System.out.println("啥都吃");
	}
}
//创建子类--可以使用父类的功能，减少子类的代码量
class dog extends Animal{
	@Override//重写方法的标记--注解 
	//重写发生在子类想要改变父类原来的功能时
	public void eat() {
		System.out.println("狗吃肉");
	}
}

1.3好处

1、多态可以让我们不用关心某个对象到底是什么具体类型，就可以使用该对象的某些方法。

2、提高了程序的扩展性、可维护性、程序的通用性/统一标准(只能调用父类的)。

1.4使用

1、成员变量：使用的是父类的。

2、成员方法：由于存在重写现象所以使用的是子类的。

3、静态成员：随着对象而存在，谁调用的就返回谁的。

package cn.tedu.oop;
//测试  多态的使用
public class Test2 {
	public static void main(String[] args) {
		fu f = new zi();
		System.out.println(f.age);//使用父类
		f.show();//重写，使用父类的方法声明，使用子类的方法体
		f.eat(); //没重写，使用父类的方法声明和方法体
//		f.sleep//多态对象不能用子类扩展的
		f.game();//静态方法在多态中不能被重写
	}
}
class fu{
	int age = 10;
	public void show() {
		System.out.println(123);
	}
	public void eat() {
		System.out.println(123+"白小纯");
	}
	public static void game() {
		System.out.println("大江大河");
	}
}
class zi extends fu{
	int age = 20;
	@Override
	public void show() {
		System.out.println(123456);
	}
	public void sleep() {
		System.out.println(123+"睡觉");
	}
	public static void game() {
		System.out.println("大江大河123");
	}
}

二、异常

2.1概述

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

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

2.2异常的继承结构

Throwable - 顶级父类

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

-- Exception：可修复的错误

--RunTimeException

--ClassCastException

--ClassNotFoundException

2.3异常处理

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

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

1、捕获方式：

try{

需要捕获的代码

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

处理方案

}

2、抛出方式：

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

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

package cn.tedu.oop;
import java.util.Scanner;
//测试  异常
public class Test3 {
	public static void main(String[] args) throws Exception {
//		method();//暴露异常
		method1();//捕获异常
		method2();//抛出异常，不推荐
	}
	public static void method2() throws Exception {
		//在方法声明处添加：throws 异常类型
		System.out.println("请输入第一个整数");
		int a = new Scanner(System.in).nextInt();
		System.out.println("请输入第二个整数");
		int b = new Scanner(System.in).nextInt();
		System.out.println(a/b);
	}
	public static void method1() {
		try {
			System.out.println("请输入第一个整数");
			int a = new Scanner(System.in).nextInt();
			System.out.println("请输入第二个整数");
			int b = new Scanner(System.in).nextInt();
			System.out.println(a/b);
		}catch(Exception a) {
			System.out.println("输入正确的数");
		} 
	}
	public static void method() {
		System.out.println("请输入第一个整数");
		int a = new Scanner(System.in).nextInt();
		System.out.println("请输入第二个整数");
		int b = new Scanner(System.in).nextInt();
		System.out.println(a/b);
	}
}

三、抽象类(abstract关键字)

3.1概述

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

抽象类可以理解为是一个只有方法声明没有方法体的特殊类。
抽象类没有方法体变成抽象方法。
有抽象方法的类，这个类必须是抽象类。

举例：水果，东西。。

3.2特点

1、通过java关键字abstract实现。

2、可以修饰方法或者类。

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

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

5、子类继承了抽象类以后，要么还是一个抽象类，要么就把所有抽象方法都重写,普通方法想改才重写。可以有自己的扩展方法。

6、多用于多态中、抽象类不可以被实例化(不能new)、构造方法不能被继承。

package cn.tedu.oop;
//测试  抽象类
public class Test4 {
	public static void main(String[] args) {
		Fut ff = new Zia();
		ff.eat();
		ff.game();
		ff.show();
	}
}
abstract class Fut{
	public abstract void eat();//抽象方法
	public abstract void game();
	public void show() {//普通方法
		System.out.println("哇哈哈哈");
	}
}
class Zia extends Fut{//不想当抽象类，重写父类的方法
	@Override
	public  void eat() {//继承抽象方法必须全部重写,可以有自己的扩展方法
		System.out.println("吃吃吃");
	}
	@Override
	public  void game() {
		System.out.println("玩玩玩");
	}
	@Override
	public void show() {
		System.out.println("哇哈哈哈123");
	}
}
abstract class Ziq extends Fut{
	//子类继承抽象的父类，父类的抽象方法也继承了，子类也必须是抽象类
}

3.3测试抽象类中的构造方法、成员变量、方法

public static final int AGE = 10;//抽象类里常量的标准写法
String name = "王林";//抽象类里成员变量的写法

package cn.tedu.oop;
//测试  抽象类的具体用法 abstract
public class Test5 {
	public static void main(String[] args) {
		demo d = new demo1();
		d.name = "白小纯";
		System.out.println(d.name);
//		d.AGE = 45;
		System.out.println(d.AGE);
		System.out.println(demo.AGE);//类名调用常量
		d.show();
		d.eat();
	}
}
abstract class demo{
	public static final int AGE = 10;//常量的标准写法
	String name = "王林";//成员变量
	 public   demo() {
		 System.out.println("这是父类构造方法，用来new的");
	 }
	 public void show() {
		 System.out.println("普通方法");
	 }
	 public abstract void eat();
}
class demo1 extends demo{
	public demo1() {
		System.out.println("这是子类构造方法，用来new的");
	}
	@Override
	public void eat() {
		System.out.println("父类抽象方法的重写");
	}
}

四、拓展

4.1静态代码块、构造代码块、局部代码块

！！！执行顺序：静态代码块—>构造代码块—>构造函数

7、静态代码块：在类加载时就加载，并且只被加载一次，一般用于项目的初始化。

8、构造代码块：在创建对象时会自动调用，每次创建对象都会被调用。

9、局部代码块：方法里的代码块。

4.2静态变量和实例变量的区别

在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。

在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。