java 继承 封装 多态 详解

最新推荐文章于 2024-09-09 14:38:59 发布
最新推荐文章于 2024-09-09 14:38:59 发布
阅读量617 收藏 4
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cincoutcin/article/details/80295018
版权

1、继承

1、1子类能够继承父类的哪些成员？

1、1、1 public 成员
1、1、2 protected 成员
1、1、3 同一个包中：缺省访问类型的成员
1、1、4 打死不能继承private成员，但是子类可以通过调用父类的set/get方法访问
1、1、5不能继承构造函数，只能通过super()调用，具体调用哪一个，还得结合传入的参数匹配。


1、2 继承的特点：

1、2、1 父变子类必须变
1、2、2 继承是一种强耦合关系
1、2、3 向上转型：父类的引用能够指向子类对象，但父类的引用只能够访问父类的成员，对于子类自身的成员就无能为力了。


1、3 继承关键子 ：extends

1、4 代码实例：

父类：

package parent_child;

public class P {
	//成员变量
	private int private1=10;
	protected int protected1=10;
	public int public1=10;
	int friendly1=10;
	
	//构造函数
	public P() {
		super();
		System.out.println("父类——无参——构造函数被调用");
	}
	
	public P(int public1, int friendly1) {
		super();
		this.public1 = public1;
		this.friendly1 = friendly1;
		System.out.println("父类——两个参数——构造函数被调用");
	}

	public P(int private1, int protected1, int public1, int friendly1) {
		super();
		this.private1 = private1;
		this.protected1 = protected1;
		this.public1 = public1;
		this.friendly1 = friendly1;
		System.out.println("父类——四个参数——构造函数被调用");
	}
	
	//成员方法：
	public  void public1() {
		System.out.println("父类——public——方法被调用");
	}
	protected void protected1() {
		System.out.println("父类——protected——方法被调用");
	}
	private void private1() {
		System.out.println("父类——private——方法被调用");
	}
	void friendly() {
		System.out.println("父类——friendly——方法被调用");
	}


	//setter and getter
	public int getPrivate1() {
		return private1;
	}

	public void setPrivate1(int private1) {
		this.private1 = private1;
	}
}

子类：

package parent_child;

public class C extends P {
	
	private int private_child=100;
	
	public C() {
		super(23,45);//子类调用父类构造函数，通过传递的参数的个数自动的调用父类的构造方法
	}
	
	public C(int private_child) {
		super(12,13,14,15);//子类调用父类构造函数
		this.private_child = private_child;
	}
	
	public static void main(String[] args) {
		C child=new C();
		child.protected1();
		child.protected1();
		child.friendly();
		
		//针对父类的private测试：
		child.setPrivate1(1000);
		System.out.println(child.getPrivate1());
		
		
		System.out.println(child.friendly1);
		System.out.println(child.private_child);
		System.out.println(child.protected1);
		System.out.println(child.public1);
	}

}

结果：



2、封装：

2、1 封装到底在干什么？
将属性私有化，通过提供公有的方法访问

2、1实例代码：
package worktest;

public class WorkTest_ {
	private int age;
	private int sex;//0_男 1_女
	private String name;
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public int getSex() {
		return sex;
	}
	public void setSex(int sex) {
		this.sex = sex;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
}

3、多态

3、1 多态到底是什么意思？

        多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。

3、2 简单总结：

        指向子类的父类引用由于向上转型了，它只能访问父类中拥有的方法和属性，而对于子类中存在而父类中不存在的方法，该引用是不能使用的，尽管是重载该方法。若子类重写了父类中的某些方法，在调用该些方法的时候，必定是使用子类中定义的这些方法（动态连接、动态调用）。

3、3 实现条件：继承、重写、向上传递
3、4实现方法：     
    1、基于继承：
package parent_child;

public class P {
	//成员变量
	private int private1=10;
	protected int protected1=10;
	public int public1=10;
	int friendly1=10;
	
	//构造函数
	public P() {
		super();
		System.out.println("父类——无参——构造函数被调用");
	}
	
	public P(int public1, int friendly1) {
		super();
		this.public1 = public1;
		this.friendly1 = friendly1;
		System.out.println("父类——两个参数——构造函数被调用");
	}

	public P(int private1, int protected1, int public1, int friendly1) {
		super();
		this.private1 = private1;
		this.protected1 = protected1;
		this.public1 = public1;
		this.friendly1 = friendly1;
		System.out.println("父类——四个参数——构造函数被调用");
	}
	
	//成员方法：
	public  void public1() {
		System.out.println("父类——public——方法被调用");
	}
	protected void protected1() {
		System.out.println("父类——protected——方法被调用");
	}
	private void private1() {
		System.out.println("父类——private——方法被调用");
	}
	void friendly() {
		System.out.println("父类——friendly——方法被调用");
	}


	//setter and getter
	public int getPrivate1() {
		return private1;
	}

	public void setPrivate1(int private1) {
		this.private1 = private1;
	}
	//测试多态
	public void PrintlnStr() {
		System.out.println("父类方法自己的方法被调用");
	}
}


package parent_child;

public class C extends P {
	
	private int private_child=100;
	
	public C() {
		super(23,45);//子类调用父类构造函数，通过传递的参数的个数自动的调用父类的构造方法
	}
	
	public C(int private_child) {
		super(12,13,14,15);//子类调用父类构造函数
		this.private_child = private_child;
	}
	
	public void PrintlnStr() {
		System.out.println("子类方法自己的方法被调用");
	}
	
	public static void main(String[] args) {
		C child=new C();
		child.protected1();
		child.protected1();
		child.friendly();
		
		//针对父类的private测试：
		child.setPrivate1(1000);
		System.out.println(child.getPrivate1());
		
		
		System.out.println(child.friendly1);
		System.out.println(child.private_child);
		System.out.println(child.protected1);
		System.out.println(child.public1);
		
		//测试多态：
		P pc=new C();		
		pc.PrintlnStr();
	}

}
    2、基于接口：
3、5 经典实例（借用一个面试题）：
package worktest;
class A {
    public String show(D obj) {
        return ("A and D");
    }

    public String show(A obj) {
        return ("A and A");
    } 

}

 class B extends A{
    public String show(B obj){
        return ("B and B");
    }
    
    public String show(A obj){
        return ("B and A");
    } 
}

 class C extends B{

}

class D extends B{

}

public class Test1 {
    public static void main(String[] args) {
    	
        A a1 = new A();
        A a2 = new B();
        B b = new B();
        C c = new C();
        D d = new D();
        
        System.out.println("1--" + a1.show(b));
        System.out.println("2--" + a1.show(c));
        System.out.println("3--" + a1.show(d));
        System.out.println("4--" + a2.show(b));
        System.out.println("5--" + a2.show(c));
        System.out.println("6--" + a2.show(d));
        System.out.println("7--" + b.show(b));
        System.out.println("8--" + b.show(c));
        System.out.println("9--" + b.show(d));      
    }
}

结果：


     其实在继承链中对象方法的调用存在一个优先级：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。


       当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法，但是它仍然要根据继承链中方法调用的优先级来确认方法，该优先级为：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。



BOUBOU1
关注
Java-封装 继承 多态
qq_57935389的博客
03-24 776
封装（数据的隐藏） 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。 记住这句话就够了：属性私有，get/set package MIanxing; /* 封装的优点： 1.提高程序点的安全性，保护数据 2.隐藏代码的实现细节 3.统一接口 4.系统可维护增加了 */ //属性私有 private public class Demo02 { private String name; private int age;
详解Java中的封装、继承、多态
08-31
在Java编程语言中，封装、继承和多态是面向对象编程的三大核心概念，它们构成了Java类库设计的基础，使得代码更加模块化、可维护和复用。 **封装**是面向对象编程的基本原则之一，其目标是隐藏实现细节，提供简洁...
Java 继承详解
dingwun11的专栏
06-16 819
什么是继承？ 多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。 多个类可以称为子类，单独这个类称为父类、超类或者基类。 子类可以直接访问父类中的非私有的属性和行为。 通过 extends 关键字让类与类之间产生继承关系。 class SubDemo extends Demo{} //SubDemo是子类，
java的封装和继承
最新发布
hehj123的博客
09-09 706
封闭， 包装封闭： 隐藏细节（类隐藏属性（不能直接访问），方法）包装： 把数据（属性）或者方法组合在一起，形成一个类（整体）， 使用类这个创建对象， 通过对象就可以访问这个类属性和方法java中封装的实现：给属性设置private访问修饰符： 属性私有化 private 私有： 本类可见 public 公开， 所有类都可以访问给属性提供公开的方法， 给属性设置值， 获取属性的值的公开方法如果一个属性有对应set方法： 可写属性如果一个属性有对应的get方法： 可读属性​//属性私有化。
Java之封装、继承，多态
weixin_74200123的博客
07-12 1219
详细的介绍了java中的三大特性，封装、继承、多态。
Java 封装 继承 多态（深入理解）
2302_79806056的博客
03-08 4419
详细解析了面向对象编程（java）的三大特性：封装继承和多态（超详细）收藏精品，帮助加深理解
java中的封装，继承，多态
weixin_51426897的博客
03-21 1490
封装： 面向对象的三大特性：封装继承和多态。 封装的意义在于保护或者防止代码（数据）被我们无意中破坏。保护成员属性，不让类以外的程序直接访问和修改。 private私有，封装原则：隐藏对象属性和实现细节，仅对外公开访问方法，并且控制访问级别。封装对象的成员属性，提供一个可供操作的方法。当私有了一个属性以后，提供一个用于设置和获取的方法。 定义一个普通的Person1类，普通的成员属性。 class Person1 { String name; int age; } 将Person1..
详解java封装继承多态
08-26
Java 封装继承多态详解 Java 中的封装、继承和多态是面向对象编程（Object Oriented Programming）三大特性。下面，我们将详细介绍这三者之间的关系和应用。 封装是指将数据和方法放入类中，并控制对数据的访问...
Java面试笔试精华：125题全面解析与继承封装多态详解
同时，这也体现了Java的封装原则，确保了数据的安全性。 接下来是"封装"，它是面向对象设计中的基石，强调将数据和操作数据的方法打包在一起，形成独立的、不可见的内部状态。这样可以防止外部对内部数据的直接修改...
java继承封装多态
11-16
Java 继承、封装、多态性详解 本节将详细介绍 Java 中的继承、封装和多态性三个基本概念，并对它们的关系和应用进行探讨。 继承 继承是 Java 中的一种机制，允许一个类继承另一个类的成员变量和方法。继承的主要...
Java面向对象：封装、继承与多态详解及示例
在Java面向对象编程中，封装、继承和多态是三大核心概念，它们构成了面向对象设计的基础。本文将对这三个概念进行深入解析，并通过示例代码来展示其在实践中的应用。 1. 封装： 封装是面向对象的重要特性，它将数据...
java 三大特性--封装、继承和多态理解
04-02
NULL 博文链接：https://lingf.iteye.com/blog/1450831
JAVA之封装·继承·多态
XINO
04-05 775
封装 多是对属性而言的 数据的隐藏，仅暴露少量方法给外部使用 关键：私有属性:get/set 举例 #student package OOP; public class student { private String name; private int id; private char sex; } #demo1 package OOP; public class demo1 { public static void main(String[] args) {
Java封装继承多态
SGLP521的博客
10-10 218
在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。 封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。 封装的优点 良好的封装能够减少耦合。 类内部的结构可以自由修改。 可以对成员变量进行更精确的控制。 隐藏信息，实现细节。 实现Java封装的步骤 修改属性的可见性来限制对属性的访问（一般限制为private），例如： public class Per
JAVA 封装 继承 多态
weixin_44952377的博客
10-19 294
一、封装 1.定义： 封装是指隐藏对象的属性和实现细节，仅仅对外提供接口。要访问该类的代码和数据，必须通过严格的接口控制。 封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。 ...
Java——封装继承多态
m0_54241717的博客
06-11 781
封装 将方法和属性封装到一个对象中，对外提供方法用于改变该对象的属性值。该代码中定义了Person类，里面的属性定义为private，外部不能通过person.name=“zf" 进行修改，只能通过person.setName(“zf”)进行修改。继承 子类可以继承父类的方法和属性Dog继承了Animal类中的方法和属性，所以就算Dog中没有定义move方法，也可以进行调用，此时调用的是父类的方法。多态 多态顾名思义就是多种形态，代码在运行时可以有多种形态。如果要满足多态，则有一些前置条件。就是必须有子类和
JAVA 封装, 继承, 多态
weixin_30731305的博客
09-18 72
继承 Java三大特征之一：继承。Java的继承具有单继承的特点，每个子类只能有一个直接父类。 继承的特点 Java的继承用extends关键字来实现，被继承的类成为父类，实现继承的类被称为子类。子类和父类的关系就比如现实生活中儿子与父亲的关系。子类继承父类所有的“特点”，子类是父类的扩展，子类是一种特殊的父类，获得父类的全部属性和方法 封装 概念理解 ...
java中封装继承多态
sinat_41302694的博客
08-02 206
封装隐藏了类的内部实现机制，可以在不影响使用的情况下改变类的内部结构，同时也保护了数据。对外界而已它的内部细节是隐藏的，暴露给外界的只是它的访问方法。 封装的深入理解 封装从字面上来理解就是包装的意思，专业点就是信息隐藏，是指利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体，数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外部发...
Java面向对象：封装、继承、多态
王洋的专栏
09-30 4228
为什么要面向对象编程？ 以前开发的过程通常是采用面向过程编程，面向过程是以过程为中心来进行编程设计，本质上是分析出需要哪些过程，在编程时一步步的对其实现，但是随着软件规模的扩大，这种面向过程的设计模式已经越来越不适应如此大规模的软件。面向过程存在着诸多的缺点比如：     1.软件重用性差 重用性是指同一事物不经修改或稍加修改就可多次重复使用的性质。软件重用性是软件工程追求的目标之一。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值