重庆—java互联网架构软件工程师学习记录—Day10（面向对象4）

最新推荐文章于 2022-12-30 22:23:04 发布

✘俗趣

最新推荐文章于 2022-12-30 22:23:04 发布

阅读量78

点赞数

分类专栏： java 互联网架构软件工程师文章标签：抽象类 java 编程语言

本文链接：https://blog.csdn.net/xlzh1314/article/details/111054444

版权

java 同时被 3 个专栏收录

14 篇文章 0 订阅

订阅专栏

软件工程师

14 篇文章 0 订阅

订阅专栏

互联网架构

13 篇文章 0 订阅

订阅专栏

Java互联网架构软件工程师——第一阶段

Day10–面向对象4

前言

1.学习抽象类及抽象类的用法
2.学习接口以及接口的使用方法

提示：以下是本篇文章正文内容，下面案例可供参考

一、异常的抛出

1.1 异常抛出

--抛出:自己不管,交给调用者处理
在方法声明上加一段代码: throws 异常类型1,异常类型2               
例如：  public static void main(String[] args)  throws Exception{

1.2 体现多态

好处1:统一调用的标准(向父类看齐)
好处2:不关心具体的子类的类型,会把子类当父类来看.屏蔽了子类间的不同,写出通用的代码
异常里,程序中出现的所有bug都应该处理,如果不知道要处理哪个异常,不知道要处理的异常还有几个.没法再写了…
用多态解决的,直接把父类Exception处理

1.3 入门案例

代码如下（示例）：

//测试 异常的处理
public class Test07 {
	public static void main(String[] args) {
		// TODO 调用了 有问题的代码，要么捕获，要么抛出
		try {
			method3();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			System.out.println("执行错误！");;
		}//抛出异常  throws 异常类型1，异常类型2...
	}
	public static void method3() throws Exception{
		// TODO Auto-generated method stub
		System.out.println("请输入两位整数：");
		int i = new Scanner(System.in).nextInt();
		int x = new Scanner(System.in).nextInt();
		System.out.println("做除法运算得："+i/x);
	}
	
}

二、抽象类

2.1 概述

如果一个方法,没有方法体,那么这个方法必须是一个 — 抽象方法.
如果类里有抽象方法,那么这个类必须修饰成 — 抽象类.
抽象类是程序设计的结果,用来优化父类的

2.2 特点

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

2.3 入门案例

代码如下（示例）：

//测试  抽象类 抽象类的特点
public class Test01 {
	public static void main(String[] args) {
		//抽象类不可以被实例化
		//fu a = new fu();
		fu a = new zi();//多态
		//多态对象只能调用父类的功能
		a.he();
		a.eat();
	}

}
//TODO 抽象类 是程序设计的结果，不提供方法体、
//TODO 类里包含抽象方法，就是一个抽象类
//TODO 抽象类灵活，可以有普通方法，也可以是抽象方法
abstract class fu{
	public void eat(){
		System.out.println("吃饭");
	}
	// TODO 没有方法体的方法叫 抽象方法
	abstract public void he();
	
}
//子类 继承 抽象类后 ，可以是一个抽象的子类
/*abstract class zi extends fu{
}*/
//TODO 子类继承抽象类后，可以重写抽象方法
class zi extends fu{
	public void he(){
		System.out.println("喝茶");
	}
	
}

三、抽象类的用法

3.1 构造方法成员变量

总结:
1,抽象类里有构造方法,不是为了自己new,为了子类new
2,抽象类里有变量,有常量
3,常量的值一旦定义就不能改了.
4,继承时,除了private和构造方法,都可以被继承的

代码如下（示例）：

//测试 使用 抽象类 构造方法 成员变量/常量

//总结
//1.抽象类里有 构造方法 ，不是为了自己new，为了子类 new
//2.抽象类里有 变量 ，常量；  常量的值一旦定义就不能改了
public class Test02 {
	public static void main(String[] args) {
		fu2 x=new zi2();
		x.name="xiaoxiao";
		System.out.println(x.name);//获取变量的值
		
//		fu2.age = 40;//常量的值不能改
		
	}

}

abstract class fu2{
	//TODO 1. 抽象类里可以有  ---构造方法  构造函数 
	//构造方法一般用来new，抽象类不能new
	public fu2(){
		System.out.println("44");
	}
	//TODO 2. 抽象类里可以有 --- 成员变量
	String name = "小芳";
	//TODO 3. 抽象类里可以有  ---常量
	public static final int age = 10;
	
	abstract public void sleep();
}
class zi2 extends fu2{
	public zi2(){
		System.out.println(1);
	}
	public void sleep(){
		System.out.println("shuijaio");
	}
}

3.2 成员方法

总结:
1,抽象类很灵活,因为可以有普通方法也可以有抽象方法
2,子类继承抽象类以后,
要么就还是一个抽象类(包含着抽象方法)
要么是重写所有抽象方法
3,子类怎么决定到底要重写哪个方法呢?
对于普通方法,想改就重写
对于抽象方法,不重写全的话,就是一个抽象的子类

代码如下（示例）：

//测试  使用抽象类   成员方法

//总结 
//1.抽象类可以普通方法，也可以有抽象方法
//2.子类继承抽象类后
    //要么还是一个抽象类（包含抽象方法）
    //要么是重写 所有 抽象方法
//3.子类怎么决定到底要重写哪个方法呢？
    //对于普通方法，想重写就重写
    // 对于抽象方法，不重写全的话，就是一个抽象的类
public class Test03 {
	public static void main(String[] args) {
		//TODO 抽象类里都是抽象方法
		x a= new y();
		a.eat();
		a.sleep();
		//TODO 抽象类里都是普通方法
		x1 b = new y1();
		b.eat();
		b.sleep();
		//TODO 抽象类里有普通方法和抽象方法
		x2 c = new y2();
		c.detele();
		c.save();
	}

}
//TODO 1.抽象类里都是抽象方法
abstract class x{
	abstract public void eat();
	abstract public void sleep();
}
class y extends x{
	@Override
	public void eat(){
		System.out.println("肉");
	}
	@Override
	public void sleep() {
		// TODO Auto-generated method stub
		System.out.println("睡觉");
	}
}

//TODO 2.抽象类里都是普通方法
abstract class x1{
	public void eat(){
		System.out.println("chi ");
	}
    public void sleep(){
		System.out.println(444);
	}
}
class y1 extends x1{
	//由于抽象类里没有 抽象方法 ，都是普通方法
	//普通方法不是必须重写的；想改时才重写
	public void detete(){
		System.out.println(174);
	}
}

//TODO 3.抽象类里有普通方法和抽象方法
abstract class x2{
	abstract public void save();
	public void detele(){
		System.out.println("删除");
	}
}

class y2 extends x2{
	public void save(){
		System.out.println("保存");
	}
	
}

四、接口

4.1 概述

接口为了突破java单根继承的局限性而来
接口支持多继承,多实现,在继承的同时多实现

4.2 特点

—接口中都是抽象方法
—通过interface关键字创建接口
—通过implements让子类来实现
—可以理解成，接口是一个特殊的抽象类
—接口突破了java的单继承的局限性
—接口和类之间可以多实现，接口和接口之间可以多继承
—接口是对外暴露的规则，是一套开发规范
—接口提高了程序的功能扩展，降低了耦合性

4.3 入门案例

代码如下（示例）：

//测试接口

public class Test04 {
	public static void main(String[] args) {
		//TODO 测试 
		father x = new son();
		x.save();
	}

}
// interface 定义接口，都是抽象方法
//TODO 接口第一个特殊的 抽象类，特殊在全是抽象方法
interface father{
	//都是抽象方法
	abstract public void save();
	abstract public void detele();
}
//是向类使用接口，发生实现关系 implements
/*abstract class son implements father{
	//实现类 要么还是一个抽象类 
}*/

class son implements father{
	//实现类  要么重写所有方法
	public void save (){
		System.out.println("保存");
	}
	public void detele (){
		System.out.println("保存");
	}
}

五、接口的使用

5.1 简单用法

代码如下（示例）：

//测试  接口的使用 （简单）

public class Test05 {
	public static void main(String[] args) {
		Inter x = new InterImpl();
		//x.name = "hcsdu";//name 是	final
		System.out.println(Inter.name);//name 
	}

}
//接口里的资源都是public的
interface Inter{
	// TODO 1.接口里有构造方法吗?---没有
	// TODO 2.接口里有变量吗?---没有！
	String name = "hadjkas";//常量的简写，会自动拼接 public static final
   //public static final String name = "hadjkas";
    
	//YODO 3.接口里的抽象方法
	abstract public void a();
	void b();//简写的抽象方法
	//接口会为简写的抽象方法，自动拼接public abstract
	
}

class InterImpl implements Inter{
	@Override
	public void a() {
		// TODO Auto-generated method stub
		System.out.println("454");
	}
	@Override
	public void b() {
		// TODO Auto-generated method stub
		
	}
	
}

5.2 复杂用法

代码如下（示例）：

//测试接口的使用（复杂）

public class Test06 {
	public static void main(String[] args) {
		// 多态对象测试
		Inter1 x = new InterImpl1();
		//只能调用左侧提供的功能
		x.save();
		// 右侧的实现类和左侧的 接口 要有实现关系
		Inter3 s = new InterImpl1();
		s.save();
	}
}
//定义接口
interface Inter1{
	void save();
}
interface Inter2{
	void get();
}
//TODO 接口键的多继承 ;接口和接口间是继承关系，而且是多继承
interface Inter3 extends Inter1 , Inter2{
	void detele();//同时拥有1 2 3 接口的功能
}


//实现类和接口 -- 是实现关系，还能多实现
class InterImpl1 implements Inter1,Inter2,Inter3{
//需要重写1 2 接口里的抽象方法，否则就是抽象类
//接口里的方法是public，重写是需给足够的权限！
	@Override
	public void get() {
		System.out.println("ss");
	}
	@Override
	public void save() {
		System.out.println("cc");
		
	}
	@Override
	public void detele() {
		// TODO Auto-generated method stub
		
	}
}

六、扩展

6.1 向上造型和向下造型有什么区别

向上造型和向下造型的区别
向上造型就是多态,为了标准化,向父类看齐
—Father f = new Son();
向下造型为了使用子类特有的扩展的
—Son son = (Son) f ;

6.2 抽象类和接口的区别

1、抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。

2、抽象类要被子类继承，接口要被类实现。

3、接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现

4、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。

5、抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。

6、抽象方法只能申明，不能实现，接口是设计的结果，抽象类是重构的结果

7、抽象类里可以没有抽象方法，如果要扩展抽象类的新方法，子类将很容易的就能得到这些新方法。

8、如果一个类里有抽象方法，那么这个类只能是抽象类

9、抽象方法要被实现，所以不能是静态的，也不能是私有的。

10、接口可继承接口，并可多继承接口，但类只能单根继承。

6.3 了解软件设计的开闭原则OCP

开放功能扩展，关闭源码修改。等

开闭原则的英文全称是Open Close Principle，缩写是OCP，它是Java世界里最基础的设计原则，它指导我们如何建立一个稳定的、灵活的系统。

开闭原则的定义是：软件中的对象（类、模块、函数等）应该对于扩展是开放的，但是对于修改是封闭的。

开闭原则，是一种设计模式，随着面向对象程序设计的思想，应运而生。

开，指的是可以在源代码的基础上进行扩展，比如继承，接口，抽象类等。在JAVA中，之所以用继承，是在可以直接调用类库的前提下，对其功能进行扩展。不需要应用者去了解封装类的内部逻辑就可以做开发。

闭：指不允许对原有的代码进行修改。以免影响其他现有功能，造成功能瘫痪。

总结

以上就是今天所学的全部内容到此面向对象就差不多全部结束了，马上要开始下个知识的学习了，基础部分一定要记牢，多敲敲代码才会有感觉，基础没有打牢，后面的部分是很难学下去的，加油！

✘俗趣

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
重庆—java互联网架构软件工程师学习记录—Day10（面向对象4）

系列文章目录Java互联网架构软件工程师——第一阶段Day10–面向对象4文章目录系列文章目录Java互联网架构软件工程师——第一阶段前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结前言提示：这里可以添加本文要记录的大概内容：例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。提示：以下是本篇文章正文内容，下面案例可供参考一、pandas是什么？示例：pandas 是基于NumPy 的一种工具，该
复制链接

扫一扫