封装、继承、多态

最新推荐文章于 2023-05-16 01:02:03 发布
最新推荐文章于 2023-05-16 01:02:03 发布
阅读量623 收藏
点赞数
分类专栏： # Java基础 文章标签： java 封装 继承 多态
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Tower_SHR/article/details/118018747
版权

文章目录

面向对象的封装性

为什么封装

新建两个类：用户类、用户测试类

package day01.encapsulation;
/**
 * @author 衣鱼
 *用户类
 */
public class User {
	int age;
}


package day01.encapsulation;
/**
 * @author 衣鱼
 *用户的测试类
 * user类中的age属性在外部程序中可以随意访问，导致age属性
 * 不安全。用户年龄被任意修改，年龄不可能为负数，以下程序当中的年龄被设置为负数
 * 程序运行时没有报错，这就是当前程序的缺陷。
 * 
 * 面向对象：封装
 * 封装之后，看不到事物复杂的内部，只能看到简单的操作入口
 * 照相机的实现原理很复杂，但是对于用户拍照的操作很简便。
 * 封装之后才会形成真正的对象，真正的“独立体”
 * 
 * 封装之后，对于事物本身提高了安全性；
 * 封装意味着以后的程序可以成分使用
 */
public class UserTest {
	public static void main(String[] args) {
		//初始化对象
		User u = new User();
		//访问age
		System.out.println("用户的年龄为"+u.age);
		//修改年龄
		u.age=23;
		System.out.println("用户年龄为"+u.age);
		//修改年龄
		//这里的age属性，显然是完全暴露给测试类（外部程序）
				u.age=-125;
				System.out.println("用户年龄为"+u.age);
	}
}

怎么封装

  • 1、封装的步骤
    所有属性私有化，使用private关键字修饰，private表示私有的，修饰的所有数据只能在本类中访问
    此时进行测试，编译报错 age属于私有化 ，外部程序不能直接访问。对于目前的程序来说，age彻底不能被外部访问。

  • 2、提供简单拿到操作入口
    外部程序想要访问age属性时，必须通过这些简单的入口进行访问。
    一个属性访问形式：读取属性的值get、修改属性的值set。
    对外提供两个公开方法：get方法、set方法。
    命名规范：
    public void setAge（int a）{ //【this关键字文章可以加深理解】
    age = a；
    }
    public int getAge（int a）{
    return age；
    }

  • 3、setter、getter方法没有static关键字
    static关键字的调用：类名.方法名（实参）
    没有static关键字修饰的方法：引用.方法名（实参）

package day01.encapsulation02;

/**
 * @author 衣鱼
 *	1、封装的步骤
 *			所有属性私有化，使用private关键字修饰，private表示私有的，修饰的所有数据只能在本类中访问
 *			此时进行测试，编译报错 age属于私有化 ，外部程序不能直接访问。对于目前的程序来说，age彻底不能被外部访问。
 *	2、提供简单拿到操作入口
 *			外部程序想要访问age属性时，必须通过这些简单的入口进行访问。
 *			一个属性访问形式：读取属性的值get、修改属性的值set。
 *			
 *			对外提供两个公开方法：get方法、set方法。
 *			命名规范：
 *					public void setAge（int a）{
 *							age = a；
 *					}		
 *					public int getAge（int a）{
 *							return age；
 *					}	
 *
 *		3、setter、getter方法没有static关键字
 *			  static关键字的调用：类名.方法名（实参）
 *			  没有static关键字修饰的方法：引用.方法名（实参）
 *					
 *
 */
public class User {
	private int age;		//一个属性：get、set
	
	
	
	public void setAge( int a) {
		//编写业务逻辑代码进行安全控制：避免出现年龄是负数的情况
		//age = a;
		if(a>=150||a<=0) {
			System.out.println("抱歉您输入数据错误！");
			return;			//“return”语句的出现在返回值为void的方法中，
							//目的是为了结束当前方法—弹栈。仅仅是“return；”，不能返回值“return 100；”
		}
		//输入数据合法,进行赋值
		age = a;
	}
	public int getAge() {
		return age;
	}
}

快速自动生成set、 get方法
在这里插入图片描述

面向对象的继承性

  • 一、继承是java的三大特性之一
  • 二、继承的作用
    • 1、代码复用
    • 2、有了继承，可以为”方法覆盖“”多态机制“提供条件！！
  • 三、继承的语法格式；
    - [修饰符列表] class 类名 extends 父类名{
    类体=属性+方法
    }
  • 四、java语言当中继承只支持单继承，一个类不能同时继承多类，只能继承一个类
    在C++中支持多继承
  • 五、继承的语义：
    B类继承A类 ： A类称为父类、基类、superclass；B类称为子类、派生类、subclass
  • 六、子类继承父类的数据
    • 私有不支持继承
    • 构造方法不支持继承
    • 其他数据均可被继承
  • 七、java支持单继承，但是一个类也可以间接继承其他类，1继承2，2继承3，1间接继承3
  • 八、java语言中假设一个类没有显示得继承任何类，那么该类默认继承java库中提供的java.lang.Object类
    在这里插入图片描述在这里插入图片描述

新建三个类：Account、CreditAccount、ExtendTest

package day01.ExtendsFeatures;

public class Account {
	private String actno;
	private  double banlance;
	public Account(String actno, double banlance) {
		
		this.actno = actno;
		this.banlance = banlance;
	}
	public Account() {
	
	}
	public String getActno() {
		return actno;
	}
	public void setActno(String actno) {
		this.actno = actno;
	}
	public double getBanlance() {
		return banlance;
	}
	public void setBanlance(double banlance) {
		this.banlance = banlance;
	}
}


package day01.ExtendsFeatures;

public class CreditAccount extends Account {
	//private String actno;
	//private double balance;
	private double credit;
	
	public CreditAccount() {
		super();
	}
	public double getCredit() {
		return credit;
	}
	public void setCredit(double credit) {
		this.credit = credit;
	}
}


package day01.ExtendsFeatures;

/**
 * @author 衣鱼
 *		一、继承是java的三大特性之一
 *		二、继承的作用
 *				1、代码复用
 *				2、有了继承，可以为”方法覆盖“”多态机制“提供条件！！
 *		三、继承的语法格式；
 *				[修饰符列表] class 类名 extends 父类名{
 *					类体=属性+方法
 *				}
 *		四、java语言当中继承只支持单继承，一个类不能同时继承多类，只能继承一个类
 *	在C++中支持多继承
 *		五、继承的语义：
 *				B类继承A类  ： A类称为父类、基类、superclass；B类称为子类、派生类、subclass
 *		六、子类继承父类的数据
 *				私有不支持继承
 *				构造方法不支持继承
 *				其他数据均可被继承
 *		七、java支持单继承，但是一个类也可以间接继承其他类，1继承2，2继承3，1间接继承3
 *		八、java语言中假设一个类没有显示得继承任何类，那么该类默认继承java库中提供的java.lang.Object类
 */
public class ExtendsTest {
	public static void main(String[] args) {
		CreditAccount act = new CreditAccount();
		act.setActno("act-001");		//CreditAccount类里面有Actno函数
		act.setBanlance(-1000.0);
		act.setCredit(0.99);
		System.out.println(act.getActno()+","+act.getBanlance()+","+act.getCredit());

	}
}

方法的覆盖

  • java的方法重载Overload

    • 何时使用重载
      • 当一个类当中，方法完成的功能是相似的，建议方法名相同。方便后续的编程。就像调用一个方法一样
    • 重载的构成
      在同一类当中，方法名相同，参数列表不同——类型、顺序、个数
      方法重载与方法的返回值类型无关、与修饰符列表无关。

  • java的方法覆盖

    • 一、方法覆盖、方法重写 override
    • 二、何时使用覆盖：当父类的方法已经无法满足子类的需求，子类有必要将父类的方法进行重写
    • 三、什么条件满足后，可以覆盖：
      方法重写发生在具有继承关系的子父类之间；
      返回值类型相同、方法名相同、形参列表相同
      访问权限不能更低，可以更高
      抛出异常，不能更多，可以更少。
    • 四、注意
      • 私有方法不能继承，不能覆盖
      • 构造方法不能继承，不能覆盖
      • 静态方法不存在覆盖【多态文章】
      • 覆盖只针对方法，不针对属性
package day01.ExtendsFeatures.OverrideMethod;

public class Animal {
	//所有动物都会移动
	public void move(){
		System.out.println("动物在移动");
	}
}

package day01.ExtendsFeatures.OverrideMethod;

public class Cat extends Animal {
	public void move() {
		System.out.println("猫在移动");
	}
}

package day01.ExtendsFeatures.OverrideMethod;

public class Brid extends Animal {
	
}

package day01.ExtendsFeatures.OverrideMethod;

/**
 * @author 衣鱼
 *		java的方法重载Overload
 *			何时使用重载
 *				当一个类当中，方法完成的功能是相似的，建议方法名相同。方便后续的编程
 *				就像调用一个方法一样
 *			重载的构成
 *				在同一类当中，方法名相同，参数列表不同——类型、顺序、个数
 *			方法重载与方法的返回值类型无关、与修饰符列表无关。
 *
 *		java的方法覆盖
 *			一、方法覆盖、方法重写 override
 *			二、何时使用覆盖：当父类的方法已经无法满足子类的需求，子类有必要将父类的方法进行重写
 *			三、什么条件满足后，可以覆盖：方法重写发生在具有继承关系的子父类之间；
 *					返回值类型相同、方法名相同、形参列表相同
 *					访问权限不能更低，可以更高
 */
public class OverriddTset01 {
	public static void main(String[] args) {
		//创建动物对象
		Animal a = new Animal();
		 a.move();
		//创建猫科对象
		Cat c =new Cat();
		c.move();
		//创建飞禽对象
		Brid b = new Brid();
		b.move();
	}
}

在这里插入图片描述

在这里插入图片描述

面向对象的多态性

  • java语言中的多态机制
    • 一、向上转型（upcasting）：子类型——>父类型 自动转换
      向下转型（downcasting）：父类型——>子类型 强制转换【加强制类型转换符】
      无论是向上转型、还是向下转型，两种类型之间必须有继承关系！没有继承关系不能转型
      • java.lang.ClassCastException 类型转换异常！！！这种异常总是在“向下转型”的时候发生，“向下转型”存在隐患【编译过了，运行错误】
      • 向上转型，只要编译过了，运行一定没有问题。 Animal a1= new Cat();
      • 向下转型，可能存在编译过了，运行错误！Animal a2 = new Brid(); Cat c2=(Cat)a2;
      • 避免向下转型发生错误的措施
        • 使用instanceof运算符可以避免以上的异常
  • instanceof的使用
    • 语法格式：（引用 instanceof 数据类型名）
    • 以上运算符执行结果类型是布尔类型，结果可能是true/false
      • （a instanceof Animal）
        ture：a这个引用指向的对象是一个Animal类型
        false：a这个引用指向的对象不是一个Animal类型
        在这里插入图片描述

多态语法机制

结合下面的代码理解

  • 1、java程序永远都分为编译阶段和运行阶段。先分析编译阶段，在分析运行阶段，一旦编译无法通过，不存在运行阶段
  • 2、编译阶段编译器检查a1这个引用数据类型为Animal00，由于Animal00.class字节码当中有move()方法，所以编译会通过这个过程被称为静态绑定，只有静态绑定成功之后，才有后续的运行。
  • 3、在程序运行阶段，JVM堆内存当中实际创建的对象是cat01对象，那么以下程序在运行阶段会调用cat01对象的move()，此时发生了动态绑定，运行阶段绑定
  • 4、无论cat01类有没有重写move方法，运行阶段调用的一定是Cat01对象的move方法，因为底层真实对象假设cat对象。
  • 5、父类型引用指向子类型对象，这种机制导致程序存在编译阶段绑定和运行阶段绑定两种不同的状态，这种机制是一种多态语法机制。
    在这里插入图片描述在这里插入图片描述
package day01.ExtendsFeatures.polymorphism;

public class Animal00 {
	//所有动物都会移动
	public void move(){
		System.out.println("动物在移动!");
	}
}

package day01.ExtendsFeatures.polymorphism;

public class Cat01 extends Animal00 {

	@Override
	public void move() {
		System.out.println("猫在移动");
	}
	//Cat特有行为：抓老鼠
	public void catchMouse(){
		System.out.println("猫抓老鼠 ！");
	}
}

package day01.ExtendsFeatures.polymorphism;

public class Brid01 extends Animal00 {

	@Override
	public void move() {
		// TODO Auto-generated method stub
		System.out.println("鸟儿在飞翔");
	}
}

package day01.ExtendsFeatures.polymorphism;
/**
 * @author 衣鱼
 * Animal、Cat、Brid的三类关系
 *			Cat继承Animal
 *			Brid继承Animal
 *			Cat和Brid没有任何继承关系
 *
 *	java语言中的多态机制
 *		一、向上转型（upcasting）：子类型——>父类型  自动转换
 *			   向下转型（downcasting）：父类型——>子类型  强制转换【加强制类型转换符】
 *			  无论是向上转型、还是向下转型，两种类型之间必须有继承关系！没有继承关系不能转型
 *		
 *		
 */
public class TestACB {
	public static void main(String[] args) {
				//创建动物对象
				Animal00 a = new Animal00();
				 a.move();
				//创建猫科对象
				Cat01 c =new Cat01();
				c.move();
				c.catchMouse();
				
				//创建飞禽对象
				Brid01 b = new Brid01();
				b.move();
				
				//使用多态机制
				/**
				 * Animal00 和 Cat01之间有继承关系，Animal00是父类 Cat的子类
				 * 
				 * Cat是Animal 【合理】
				 * new Cat() 创建的对象的类型是Cat , a1这个引用数据类型是Animal ，可见它们进行了数据转换
				 * 子类型转换成父类型，是向上转型 、自动类型转换
				 *
				 */
				Animal00 a1= new Cat01();
				/**
				 * 1、java程序永远都分为编译阶段和运行阶段。先分析编译阶段，在分析运行阶段，一旦编译无法通过，不存在运行阶段
				 * 2、编译阶段编译器检查a1这个引用数据类型为Animal，由于Animal.class字节码当中有move()方法，所以编译会通过，这个过程被称为静态绑定，只有静态绑定成功之后，才有后续的运行。
				 * 3、在程序运行阶段，JVM堆内存当中实际创建的对象是cat01对象，那么以下程序在运行阶段会调用cat01对象的move()， 此时发生了动态绑定，运行阶段绑定
				 * 4、无论cat01类有没有重写move方法，运行阶段调用的一定是Cat01对象的move方法，因为底层真实对象假设cat对象。
				 * 5、父类型引用指向子类型对象，这种机制导致程序存在编译阶段绑定和运行阶段绑定两种不同的状态，这种机制是一种多态语法机制。
				 */
				a1.move();		
				/**
				 * 此时有需求，让a1去抓老鼠：
				 * a1无法直接调用，a1是Animal00类型。此时需要强制类型转换 【当调用的方法是子类型中特有的，在父类型当中不存在，必须进行向下转型】
				 * 
				 * 注意！！向下转型也需要两种类型之间必须有继承关系，不然编译会报错
				 * 强制类型转换符
				 */
				Cat01 c1= (Cat01)a1;
				c1.catchMouse();		
				
				Animal00 a2 = new Brid01();
		        //Cat01 c2=(Cat01)a2;		//运行错误 
				//使用instanceof运算符可以避免以上的异常
				if(a2 instanceof Cat01) {
					Cat01 c3=(Cat01)a2;
					c3.catchMouse();
				}
				else if(a2 instanceof Brid01) {
					Brid01 b2 = (Brid01)a2;
					b2.move();
				}
	}
}

在这里插入图片描述在这里插入图片描述

多态的作用

  • 多态在实际开发中的作用：以饲养动物为例

    • 分析场景，抽象类型
      主人类、动作：喂养
      宠物类、动作：进食

  • 面向对象编程的核心：定义好类，然后将类实例化为对象，给一个环境驱使，使各个对象协作起来形成一个系统。

  • 多态的作用
    降低程序的耦合度，提高程序的扩展力
    父类型引用指向子类型对象
    面向抽象编程，尽量不要面对具体编程

主人喂养宠物，建立Master、Cat、Dog、Test类
随着宠物类别的增加，传统的feed函数需要多次编写，扩展性差。
例题利用多态解决了该问题

package day01.polymorphism;

public class Cat extends Pet {
	//猫吃鱼
	public void eat() {
		System.out.println("小猫在吃鱼");
	}
}

package day01.polymorphism;

public class Dog extends Pet{
	public void eat() {
		System.out.println("小狗在吃骨头");
	}
}

package day01.polymorphism;

public class Pet {
	public void eat() {
		//所有宠物都可以吃
	}
}


package day01.polymorphism;
/**
 * 这种方式没有使用使用java的多态机制：Master类的扩展能力很差
 * 只要添加一个新的宠物，Master就要添加一个新方法！
 * Msater 和Cat Dog两个类型的关联程度很高，耦合度很高、扩展性很差
public class Master {
	// 主人喂养宠物  
	public void feed(Cat c) {		//关联
		c.eat();
	}
	public void feed(Dog d) {		//关联  方法重载
		d.eat();
	}
}
*/

//降低程序的耦合度、提高程序的扩展力
//添加一个宠物类  宠物Cat、Dog继承宠物类Pet
//Master面对是是一个抽象的Pet，不再是一个具体的宠物
public class Master{
	public void feed(Pet pet) {  //pet的一个父类型的引用，传入参数jery是一个子类型的对象
		pet.eat();
	}
}


package day01.polymorphism;

/**
 * @author 衣鱼
 *	多态在实际开发中的作用：以饲养动物为例
 *		分析场景，抽象类型
 *			-主人类、动作：喂养
 *			-宠物类、动作：进食
 *面向对象编程的核心：定义好类，然后将类实例化为对象，给一个环境驱使，使各个对象协作起来形成一个系统。
 *
 *多态的作用
 */
public class Test {
	public static void main(String[] args) {
		Master xian = new Master();
		Cat jery = new Cat();	
		//喂猫
		xian.feed(jery);
		//喂狗
		Dog doudou = new Dog();
		xian.feed(doudou);			
	}
}

在这里插入图片描述在这里插入图片描述

今天论文也要改
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java之封装，继承，多态
a127389的博客
09-04 1066
一，前言 ​ 今天总结一下关于Java的三大特性，封装，继承，多态。其实关于三大特性对于从事编程人员来说都是基本的了，毕竟只要接触Java这些都是先要认识的，接下来就系统总结一下。 二，封装 ​ 先来说说特性之一：封装 2.1，什么是封装 ​ 封装（Encapsulation）是面向对象方法的重要原则，就是把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。...
C#封装继承多态
11-05
这是关于C#封装继承多态的一个简单的例子，对于深入学习C#中封装继承多态将很有帮助！
封装继承多态
JieBanRen的博客
04-29 2926
封装的目的 增强安全性和简化编程，使用者不必了解具体的实现细节，而只要通过对外公开的访问方法，来使用类的成员。 封装的基本要求 把所有的属性私有化。 对每个属性提供 getter 和 setter 方法。 如果有一个带参的构造函数的话，那一定要写一个不带参的构造函数。 建议重写 toString 方法，但这不是必须的。 继承 可以理解为，在一个现有类的基础之上，增加新的方法或重写已有方法，从而产生...
封装，继承，多态
qq_59561046的博客
05-16 4743
面向对象程序三大特性：封装、继承、多态。面向对象程序三大特性：封装、继承、多态。而类和对象阶段，主要研究的就是封装特性。何为封装呢？简单来说 就是套壳屏蔽细节。比如：对于电脑这样一个复杂的设备，提供给用户的就只是：开关机、通过键盘输入，显示器，USB插孔等，让用户来和计算机进行交互，完成日常事务。但实际上：电脑真正工作的却是CPU、显卡、内存等一些硬件元件。对于计算机使用者而言，不用关心内部核心部件，
如何理解封装、继承和多态
热门推荐
c_w_d的博客
10-31 6万+
封装： 　封装是实现面向对象程序设计的第一步，封装就是将数据或函数等集合在一个个的单元中（我们称之为类）。被封装的对象通常被称为抽象数据类型。   封装的意义： 　　封装的意义在于保护或者防止代码（数据）被我们无意中破坏。在面向对象程序设计中数据被看作是一个中心的元素并且和使用它的函数结合的很密切，从而保护它不被其它的函数意外的修改。 　　封装提供了一个有效的途径来保护数据
详解java封装继承多态
08-26
Java 封装继承多态详解 Java 中的封装、继承和多态是面向对象编程（Object Oriented Programming）三大特性。下面，我们将详细介绍这三者之间的关系和应用。 封装是指将数据和方法放入类中，并控制对数据的访问...
封装继承多态总结
12-06
封装继承多态总结
c++ 的封装继承多态例子
04-01
在C++编程语言中，封装、继承和多态是面向对象编程（OOP）的三大核心概念。下面将深入解析这三个关键概念，并结合"cppgood"这个可能包含示例代码的压缩包，来阐述它们在实际编程中的应用。 **封装** 是面向对象编程...
JavaScript使用prototype原型实现的封装继承多态示例
10-18
下面将详细介绍使用prototype实现封装、继承和多态的概念以及相关的代码示例。 首先，封装是面向对象编程中的一个核心概念，它涉及将数据（属性）和操作数据的方法捆绑在一起，形成一个独立的单元，即对象。在...
多态，封装，继承
singlecs的博客
02-08 2925
封装 封装的意义： 封装的意义在于保护或者防止代码（数据）被我们无意中破坏。 保护成员属性，不让类以外的程序直接访问和修改； 隐藏方法细节 关于对象封装的原则: 内聚：内聚是指一个模块内部各个部分之间的关联程度 耦合：耦合指各个模块之前的关联程度 封装原则：隐藏对象的属性和实现细节，仅对外公开访问方法，并且控制访问级别 在面向对象方法中，用类来实现上面的要求。用类实现封装，用封装来实现高内聚，低耦合。 继承 继承的意义： 主要实现重用代码，节省开发时间。 子类继承父类静态属性方法是否可以被继承和重写？ 结论
封装 继承 多态
最新发布
07-27
封装、继承和多态是面向对象编程中的三个重要概念。 封装是指将数据和对数据的操作封装在一个类中，通过访问修饰符来控制对数据的访问权限。这样可以隐藏内部实现细节，提高代码的安全性和可维护性。\[2\] 继承是指一个类可以继承另一个类的属性和方法。通过继承，子类可以重用父类的代码，并且可以在子类中添加新的属性和方法。这样可以提高代码的复用性和可扩展性。\[2\] 多态是指同一个方法在不同的对象上可以有不同的行为。通过多态，可以实现方法的重写和重载，使得程序可以根据对象的实际类型来调用相应的方法。这样可以提高代码的灵活性和可扩展性。\[1\] 总结起来，封装、继承和多态是面向对象编程的三个基本特性，它们可以使代码更加模块化、可维护和可扩展。 #### 引用[.reference_title] - *1* *2* [封装、继承、多态](https://blog.csdn.net/yahid/article/details/125665027)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] - *3* [C++ 类的封装继承多态](https://blog.csdn.net/secondtonone1/article/details/124485035)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值