Java学习路程之多态、设计模式、抽象和接口

最新推荐文章于 2024-04-23 14:00:00 发布

空空然

最新推荐文章于 2024-04-23 14:00:00 发布

阅读量302

点赞数

文章标签： Java 学习抽象接口设计模式

本文链接：https://blog.csdn.net/l710820742/article/details/82228312

版权

一.多态
1.多态练习

/*
 * 新建一个僵尸类
 * 
 * 铁桶僵尸 
 * 血量  初始200血
 * 方法:每次被打减少2滴血 被打死 打印 铁桶僵尸死了
 * 
 * 门框僵尸
 * 血量  300
 * 方法:每次被打减少5滴血 被打死 打印 门框僵尸死了
 * 
 * main函数中 封装一个打僵尸方法 (适用所有的僵尸)
 * 
 * 无参 有参 set/get方法
 * */
public class Day09 {
	public static void main(String[] args) {
	    //父类的引用指向子类的空间
		Zombie bucketZombie = new BucketZombie();
		bucketZombie.setBlood(200);
		hitZombie(bucketZombie);
		Zombie dwZombie = new DwZombie();
		dwZombie.setBlood(300);
		 hitZombie(dwZombie);
	}
	//通用打僵尸方法
	public void hitZombie(Zombie zombie){
		zombie.hit();
	}
}
//僵尸类
class Zombie{
	//血量变量
	private int blood;
	//构造方法
	public void Zombie(){
	
	}
	public void Zombie(int blood){
		this.blood = blood;
	}
	//set/get方法
	public void setBlood(int blood){
		this.blood = blood;
	}
	public int getBlood(){
		return blood;
	}
	//打僵尸的方法
	public void hit(){
		System.out.println("打僵尸");
	}
}
//铁桶僵尸类
class BucketZombie extends Zombie{
	//方法的重写
	public void hit(){
		while(true){
			if(getBlood() <= 0){
			System.out.println("铁桶僵尸死了");
			break;
			}
			//被打一次血量减少
			setBlood(getBlood() - 2);
			//剩余血量
			System.out.println(getBlood());
		}
	}
}
//门窗僵尸类
class DwZombie extends Zombie{
	//父类方法的重写
	public void hit(){
		if(getBlood <= 0){
			System.out.println("门窗僵尸死了");
			return;
		}
		//被打一次血量减少5点
		setBlood(getBlood() - 5);
		//剩余血量
		System.out.println(getBlood());
	}
}

/* 定义主板类 
 * (多态 继承 方法重写)
* 主板:
* 启动方法  主板启动了
* 插卡方法  start和end
* (主板上可以插很多卡 例如 例如声卡 网卡 显卡 内存条)
* 声卡可以 start播放音乐 end关闭播放
* 网卡可以 start上网 end断网
*/
public class Day09 {
	public static void main(String[] args) {
		MainBoard mainBoard = new MainBoard();
		 mainBoard.insertCard(new SoundCard());
		  mainBoard.insertCard(new NetCard());
	}
}
//定义卡类
class Card{
	//开始方法
	public void start(){
		System.out.println("开始");
	}
	//结束方法
	public void end(){
		System.out.println("结束");
	}
}
//定义主板类
class MainBoard{
    //启动方法
	public void run(){
		System.out.println("启动");
	}
	//插卡方法
	public void insertCard(Card card){
		card.start();
		card.end();
	}
}

//声卡类
class SoundCard extends Card{
	//父类方法的重写
	//开始播放音乐
	public void start(){
		System.out.println("播放音乐");
	}
	//关闭播放
	public void end(){
		System.out.println("关闭播放");
	}
}
//网卡类
class NetCard extends Card{
	//开始上网
	public void start(){
		System.out.println("开始上网");
	}
	//断网
	public void end(){
		System.out.println("断网");
	}
}

二.设计模式
1.单例设计模式
核心:在程序运行当中无论如何创建对象,该对象有且只有一个存在.
分为:
饿汉式单例
懒汉式单例
区别:

public class Day09 {
	public static void main(String[] args) {
	    //两个引用输出结果一致,具体实现见图
		HSingle hSingle1 = HSingle.getInstance();
		HSingle hSingle1 = HSingle.getInstance();
	}
}
//饿汉式单例
class HSingle{
	 //第二步创建对象
	private static HSingle hSingle = new HSingle();
	//第一步构造方法私有化
	private HSingle(){
	}
	//第三步开放一个供外部调用的方法
	public static HSingle getInstance(){
		return hSingle;
	}
}
//懒汉式单例
class LSingle{
	//构造方法私有化
	private LSingle(){}
	//创建对象
	private static LSingle lSingle = null;
	//提供外部调用的方法
	public static LSingle getInstance(){
		if (lSingle == null) {
			synchronized (LSingle.class) {
				if (lSingle == null) {
					lSingle = new LSingle();
				}
			}
		}
		return lSingle;
	}
}

饿汉式单例引用

2.模板设计模式
当你的程序大部分代码都相同,只有少部分需要修改时可以使用模板设计模式(利用抽象类)

public class Day09 {
	public static void main(String[] args) {
		School student = new XM();
		student.study();//输出:报名缴费 文科 毕业
	}
}
abstract class School{
	//  学习
	public void study() {
		System.out.println("报名缴费");
		//  选择学科
		chooseSubject();
		System.out.println("毕业");
	}
	//  抽象方法
	public abstract void chooseSubject();
}
//学生类
class XM extends School{
    //方法的重写
	@Override
	public void chooseSubject() {
		System.out.println("文科");
	}
}

class LS extends School{
	@Override
	public void chooseSubject() {
		System.out.println("理科");
	}
	
}

2.练习
打印一个程序的执行时间(使用模板设计模式)

public class Demo07 {
	public static void main(String[] args) {
		Program pro = new XH();
		pro.getTime();
	}
}
abstract class Program{
	//计算程序执行时间方法
	public void getTime(){
		//开始
		long start = System.currentTimeMillis();
		 program();
		//结束
		long stop = System.currentTimeMillis();
		//执行时间
		System.out.println("程序执行时间:" + (stop - start));
	}
	//声明抽象方法表示程序
	public abstract void program();
}
//定义一个程序类
class XH extends Program{
	public void program() {
		//执行的程序
		for (int i = 1; i <= 9; i++) {
			for (int j = 1; j <= i; j++) {
				System.out.print(j +"*"+ i +"="+j*i+"\t");
			}
			System.out.println();
		}
	}
}

三.抽象
1.含义:无法对事物进行具体的描述
关键词: abstract
修饰类该类是抽象类,修饰方法该方法是抽象方法
2.注意:
1).抽象方法没有实现部分
2)抽象方法必须在抽象类中才能声明
3)抽象类中可以没有抽象方法
4)抽象类不可以直接创建出对象,但是可以通过多态的形式创建
5)继承抽象类的子类必须实现抽象类的抽象方法
2.抽象类中可以有变量、常量、抽象方法、成员方法、构造方法
3.特点:
Java接口中的成员变量默认都是public,static,final类型的(都可省略),必须被显示初始化,即接口中的成员变量为常量(大写,单词之间用”_”分隔);
Java接口中的方法默认都是public,abstract类型的(都可省略),没有方法体,不能被实例化;
Java接口中只能包含public,static,final类型的成员变量和public,abstract类型的成员方法;
接口中没有构造方法,不能被实例化;
一个接口不能实现(implements)另一个接口,但它可以继承多个其它的接口
Java接口必须通过类来实现它的抽象方法;
当类实现了某个Java接口时,它必须实现接口中的所有抽象方法,否则这个类必须声明为抽象类;
不允许创建接口的实例(实例化),但允许定义接口类型的引用变量,该引用变量引用实现了这个接口的类的实例;一个类只能继承一个直接的父类,但可以实现多个接口，间接的实现了多继承。

public class Day09 {
	public static void main(String[] args) {
		//抽象类不能直接创建对象
		//Animal animal = new Animal();
		//使用的方法  以多态的方法创建
		Animal animal = new Cat();
		animal.eat();
		//向下转型
		Cat cat = (Cat)animal;	
		cat.catchMice();
	}
}
//动物类
abstract class Animal{
	//声明抽象方法
	public abstract void eat();
	public void Amimal() {
		System.out.println("我是构造方法");
	}
}
/猫类
class Cat extends Animal{
	//实现抽象方法
	public void eat() {
		System.out.println("猫吃鱼");
	}
	//特有方法
	public void catchMice() {
		System.out.println("抓老鼠");
	}
}

四.接口
1.定义
接口:
狭义:使用关键字interface定义接口
广义:制定一个规范让人来遵守
2.结构
interface 接口名 {}
注意:
1.使用接口时用关键词interface
2.接口类不能直接创建对象
3.接口类不能声明成员方法
4.接口类不能有构造方法
5.使用多态的方式创建对象

public class Day09 {
	public static void main(String[] args) {
		//接口类不能直接创建对象
		//Inter inter = new Inter();
		//使用多态的形式类创建对象
		Inter inter = new interImpl();
		inter.fn();
	}
}

//声明一个接口
interface Inter{
   //系统会在成员变量前加上 public static final,实际声明的是一个静态常量
	public static final int num = 10;
	//抽象方法
	public abstract void fn();
	//不能有构造方法
	//接口不能直接创建对象,而构造方法在创建对象时系统会自动调用,对象不能声明故构造方法也就不能声明了
	//public Inter() {};
}
class interImpl implements Inter{
	//实现接口中的抽象方法
	public void fn() {
		System.out.println("我是实现类的fn方法");
		System.out.println(num);
	}
}

练习:

public class Day09 {
	
}
//动物类
abstract class Animal1{
	//抽象方法
	public abstract void speak();
}
//猫类
class Cat1 extends Animal1{
	//实现抽象方法
	public void speak() {
		System.out.println("喵喵喵");
	}
}
//接口
interface interCat{
	//声明抽象方法
	public abstract void jump();
}
//实现接口//加菲猫类
class JFcat extends Cat implements interCat{
     //实现接口中的抽象方法
	public void jump() {
		System.out.println("人指导训练");
	}
}