十.JAVA核心，适合提高------JAVA语言进阶之类的封装，继承，多态

最新推荐文章于 2024-09-24 10:50:41 发布
最新推荐文章于 2024-09-24 10:50:41 发布
阅读量118 收藏
点赞数
分类专栏： java 文章标签： 多态 java 封装 类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luckism/article/details/107821764
版权

类的封装，继承，多态


本篇将详细介绍JAVA编程的核心技术
类的封装，继承，多态是面向对象的三大特性。
封装：相当于一个黑匣子，放在黑匣子里

封装

将描述某类事物的数据与处理这些数据的函数封装在一起，形成一个有机整体，称为类
封装的目的是增强安全性和简化编程，使用者不必了解具体的实现细节

封装的实现

JAVA访问权限修饰符

私有（private）
1.类：只有内部类允许私有，只能在当前类中被访问
2.属性：只能被当前类访问
3.方法：只能被当前类访问
默认（default）
1.类：可以被当前包中所有类访问
2.属性：可以被相同包中的类访问
3.方法：可以被相同包中的类访问
保护（protected）
1.类：只有内部类可以设为保护权限，相同包中的类及其子类可以访问
2.属性：可以被相同包中的类以及子类访问
3.方法：可以被相同包中的类以及子类访问

公有（public）
1.类：可以被所有类访问
2.属性：可以被所有类访问
3.方法：可以被所有类访问

继承

某一新类A继承某一既有类B时，表示这个新类A具有B类的所有成员，同时又可对既有类的成员做出修改，或是增加了新的成员。前半部分是继承，后半部分是派生。
既有类称为：基类，超类，父类
新类称为：派生类，子类

继承的基本概念

class 子类名 extends 父类

/**
 * @author 86152
 *练习，继承
 */
class person{
	 int age;
    String name;
    person(String name,int age)   //需要写构造方法，才能将姓名和年龄传进来
    {
    	this.age=age;
    	this.name=name;
    }
	public void speak()
	{
		System.out.println("My name is "+name+" and my age is "+age);
	}
}

class student extends person
{
	 String school;
	 student(String name,int age,String school){
		 super(name,age);           //super关键字，继承姓名和年龄
		 this.school=school;
	 }
	
	void study()
	{
		System.out.println("I am studying in "+school);
	}
}
public class demo {
	public static void main(String []args)
	{
		student ming= new student("ming",21,"ND");
		ming.speak();
	   ming.study();
	}


}

在这里插入图片描述

继承的限制

限制1：Java中不允许多重继承，但允许多层继承
限制2：从父类继承的私有成员，不能被子类直接使用
限制3：子类在进行对象初始化时，从父类中继承而来的数据成员需要先调用父类的构造方法来初始化，然后再用子类的构造方法来初始化本地的数据成员。
限制4：被final修饰的类不能再被继承

深度认识类的继承

子类对象的实例化过程：见：继承的限制-限制3

super关键字的使用

在“练习，继承”中，super（name，age），指名调用的是父类中含有两个参数的构造方法。
调用super必须写在子类构造方法的第一行，否则编译不通过。
super关键字不仅可用于调用父类中的构造方法，也可调用父类的属性或方法

/**
 * @author 86152
 *练习，super调用父类的属性和方法
 */
class person{
	 int age;
    String name;
    person()   //这种super的使用，不需要重写构造方法
    {
    	
    }
	public void speak()
	{
		System.out.println("My name is "+name+" and my age is "+age);
	}
}

class student extends person
{
	 String school;
	 student(String name,int age,String school){
		 //super(name,age);           //super关键字，继承姓名和年龄
		 super.name=name;
		 super.age=age;
		 this.school=school;
	 }
	
	void study()
	{
		System.out.println("I am studying in "+school);
	}
}
public class demo {
	public static void main(String []args)
	{
		student ming= new student("ming",21,"ND");
		ming.speak();
	   ming.study();
	}


}

限制子类的访问

/**
 * @author 86152
 *练习，子类访问父类的私有成员
 */
class person{
	 private int age;
    private String name;
    person(int age,String name)   //重写构造方法
    {
    	this.age=age;
    	this.name=name;
    }
    public void setarr(int age,String name)//该函数和构造函数的不同在于，构造方法是在实例化对象加载时运行一次且仅运行一次，该方法可以之后对属性再次修改
    {
    	this.age=age;
    	this.name=name;
    }
	public void speak()
	{
		System.out.println("My name is "+name+" and my age is "+age);
	}
}

class student extends person
{
	 String school;
	 student(String name,int age,String school){
		 super(age,name);           //super关键字，继承姓名和年龄
		 this.school=school;
	 }
	/*void try()
	{
		System.out.println("尝试访问父类的私有变量 "+name);
	}*/
	void study()
	{
		System.out.println("I am studying in "+school);
	}
}
public class demo {
	public static void main(String []args)
	{
		student ming= new student("ming",21,"ND");
		ming.speak();
		ming.setarr(30, "fang");
	   ming.speak();
	}


}

覆写

子类在继承父类时，重复定义了父类的属性，或者重复实现了父类的方法(名称，参数个数，类型，返回值类型等完全一致)

/**
 * @author 86152
 *练习，子类覆写父类方法
 */
class person{
	 private int age;
    private String name;
    person(int age,String name)   //重写构造方法
    {
    	this.age=age;
    	this.name=name;
    }
    public void setarr(int age,String name)//该函数和构造函数的不同在于，构造方法是在实例化对象加载时运行一次且仅运行一次，该方法可以之后对属性再次修改
    {
    	this.age=age;
    	this.name=name;
    }
	 public String speak()
	{
		return "My name is "+name+" and my age is "+age;
	}
}

class student extends person
{
	 String school;
	 student(String name,int age,String school){
		 super(age,name);           //super关键字，继承姓名和年龄
		 this.school=school;
	 }
	public String speak()
	{
		return super.speak()+".I am studying in "+school;//调用父类的方法
	}
}
public class demo {
	public static void main(String []args)
	{
		student ming= new student("ming",21,"ND");
		System.out.println(ming.speak());
		ming.setarr(30, "fang");
		System.out.println(ming.speak());
	}


}

覆写的注意点：
1.覆写方法的返回值和被覆写的方法的返回值相同
2.被覆写的方法不能是静态的
3.被覆写方法的访问权限应大于或等于覆写的访问权限
父类方法：public 子类方法：public
父类方法：default 子类方法：public，default，protected
父类方法：protected 子类方法：public，protected
父类方法：private 无法构成覆写，因为该方法对于子类来说不可见

多态

1.方法多态性，体现在方法的重载与覆写上。
方法的重载：同一个方法名称，根据传参的不同，所调用的方法体不同。
方法的覆写：父类的一个方法名称，在不同子类中有不同的功能实现。根据实例化子类的不同，同一个方法可以完成不同的功能。
2.对象多态性，体现在夫，子类的转型上
（1）向上转型
父类 父类对象=子类实例
（2）向下转型
子类 子类对象=父类实例
多态的核心概念：子类对象可以视作父类对象

多态的基本概念

/**
 * @author 86152
 *练习，多态
 */
class person{
	 private int age;
    private String name;
    person(int age,String name)   //重写构造方法
    {
    	this.age=age;
    	this.name=name;
    }
   
    public void speak1()
	{
		System.out.println("----父类speak1-------");
	}
    public void speak2()
   	{
   		System.out.println("----父类speak2-------");
   	}
}

class student extends person                              //多态实现必要条件：继承
{
	 String school;
	 student(String name,int age,String school){
		 super(age,name);           
		 this.school=school;
	 }
	 public void speak1()                                //多态实现必要条件：覆写
		{
			System.out.println("----子类speak1-------");
		}
	    public void speak2()
	   	{
	   		System.out.println("----子类speak2-------");
	   	}
}
class greatstudent extends student
{
	greatstudent(String name,int age,String school)
	{
		super(name,age,school);
		
	}
	 public void speak1()                                //多态实现必要条件：覆写
		{
			System.out.println("----子子类speak1-------");
		}
	    public void speak2()
	   	{
	   		System.out.println("----子子类speak2-------");
	   	}
	}
public class demo {
	public static void main(String []args)
	{
		person p= new greatstudent("ming",21,"ND");            //多态实现必要条件：向上继承
		p.speak1();
		p.speak2();
		
	}


}

方法多态性

即重载

对象多态性

1.向上转型
可以自动完成
2.向下转型
必须强制类型转换

/**
 * @author 86152
 *练习，父类对象找不到子类的扩充方法
 */
class person{
	 private int age;
    private String name;
    person(int age,String name)   //重写构造方法
    {
    	this.age=age;
    	this.name=name;
    }
   
    public void speak1()
	{
		System.out.println("----父类speak1-------");
	}
    public void speak2()
   	{
   		System.out.println("----父类speak2-------");
   	}
}

class student extends person                              //多态实现必要条件：继承
{
	 String school;
	 student(String name,int age,String school){
		 super(age,name);           
		 this.school=school;
	 }
	 public void speak1()                                //多态实现必要条件：覆写
		{
			System.out.println("----子类speak1-------");
		}
	    public void speak2()
	   	{
	   		System.out.println("----子类speak2-------");
	   		
	   	}
	    public void speak3()
	   	{
	   		System.out.println("----子类speak3-------");
	   		
	   	}
}

public class demo {
	public static void main(String []args)
	{
		person p= new student("ming",21,"ND");            //多态实现必要条件：向上继承
		p.speak1();
		p.speak2();
	   // p.speak3();错误，speak3()是子类新写的方法，父类是无法使用的
		
	}


}

隐藏

如果不想父类的方法被覆写应该怎么办呢？
使用关键词static ，static修饰的静态方法不能被覆盖。
所有的静态方法隶属于类，而非对象，因此可以通过“类名.静态方法名”的方法直接访问静态方法

/**
 * @author 86152
 *练习，隐藏
 */
 class father{
	public static void speak()
	{
		System.out.println("father overwirting...");
	}
}
 class son extends father
 {
	 public static void speak()
	 {
		 System.out.println("son overwriting...");
	 }
	 
 }

public class demo {
	public static void main(String []args)
	{
		father f=new son();
		f.speak();
		father.speak();//本例中希望大家关注的点
		son.speak();
		
	}


}

在这里插入图片描述

提高部分

1.重载和覆写的区别是什么？
从定义，使用范围，访问权限不同
重载：在一个类中，对与类名相同的构造方法进行重写，主要体现在在参数列表的（类型，个数，位置）的不同，对于访问权限没有特殊要求
覆写：在子类和父类当中，对于继承自父类的方法进行重写，重写要求方法名，参数，返回类型等都是相同的，子类方法的访问权限要比父类的访问权限更宽或者相同。

2.this和super的区别
从查找范围，调用的构造方法不同
this先查本类的属性和方法，在查父类的属性和方法。调用自己类的构造方法。
super直接调用父类的属性和方法。由子类调用父类构造方法。

3.final关键字的使用
final可以用来修饰类，方法，变量
1.final修饰的类不能有子类
2.final修饰的方法不能被覆写
3.final修饰的变量就成了常量

练习部分

  1. 建立一个人类（Person）和学生类（Student），功能要求如下。
    ⑴ Person中包含4个数据成员name、addr、sex和age，分别表示姓名、地址、类别和年龄。设计一个输出方法talk()来显示这4种属性。
    ⑵ Student类继承Person类，并增加成员Math、English存放数学与英语成绩。用一个6参构造方法、一个两参构造方法、一个无参构造方法和覆写输出方法talk()用于显示6种属性。对于构造方法参数个数不足以初始化4个数据成员时，在构造方法中采用自己指定默认值来实施初始化。
/**
 * @author 86152
 *练习，封装，继承，多态
 */
 class person{
	 public person() {
		 this.name="小红";
		 this.addr="上海";
		 this.sex="女";
		 this.age=20;
		
	}
	public person(String name, String addr, String sex, int age) {
		this.name = name;
		this.addr = addr;
		this.sex = sex;
		this.age = age;
	}
	String name;
	 String addr;
	 String sex;
	 int age;
	public void talk()
	{
		System.out.println("我的名字是"+name+".我住在"+addr+".我的性别是"+sex+".我今年"+age+"岁。");
	}
}
 
 class student extends person
 
 {
	 public student(double math,double english)
	 {
		 super();
		 this.math=math;
		this.english=english;
	 }
	 public student(String name,String addr,String sex,int age,double math,double english)
	 {
		 super(name,addr,sex,age);
		this.math=math;
		this.english=english;
		
	 }
	 
	 double math;
	 double english;
	 
	 public void talk()
	 {
		 super.talk();
		 System.out.println("我的英语成绩是"+english+"我的数学成绩是"+math);
	 }
	
	 
 }

public class demo {
	public static void main(String []args)
	{
		student s=new student("小明","南京","男",30,95,90);
		student s2=new student(80,75);
		s.talk();
		s2.talk();
	}


}

定义一个Instrument（乐器）类，并定义其公有方法play()，再分别定义其子类Wind（管乐器）， Percussion（打击乐器），Stringed（弦乐器），覆写play方法，实现每种乐器独有play方式。最后在测试类中使用多态的方法执行每个子类的play()方法。

/**
 * @author 86152
 *练习，封装，继承，多态
 */
 class instrument{
	
	public void play()
	{
		System.out.println("-------发出乐器声--------");
	}
}
 
 class wind extends instrument
 
 {
	 
	 
	 public void play()
	 {
		 
		 System.out.println("-------发出乐器声   管弦乐--------");
	 }
	
	 
 }
 class percussion extends instrument
 
 {
	 
	 
	 public void play()
	 {
		 
		 System.out.println("-------发出乐器声  击打乐器--------");
	 }
	
	 
 }
 class stringed extends instrument
 
 {
	 
	 
	 public void play()
	 {
		 
		 System.out.println("-------发出乐器声  弦乐器--------");
	 }
	
	 
 }
public class demo {
	public static void main(String []args)
	{
		instrument in=new instrument();
		wind wi =new wind();
		percussion per=new percussion();
		stringed str=new stringed();
		in.play();
		in=wi;
		in.play();
		in=per;
		in.play();
		in=str;
		in.play();
		
	}


}

在这里插入图片描述

lucksim
关注
专栏目录
java基础4--面向对象下（几道练习题）
pmsheep82的专栏
01-22 5127
继承、抽象类和接口的几道习题。
继承【案例分析】
chaim16的博客
11-18 1457
继承案例分析 案例一：学生类 建立一个人类（ Person）和学生类（ Student），功能要求如下： （1） Person中包含4个私有型的数据成员name、adr、sex、age，分别为字符串型、字符串型、字符型及整型，表示姓名、地址、性别和年龄。一个4参构造方法个两参构造方法、一个无参构造方法、一个输出方法显示4种属性 （2） Student类继承 Person类，并增加成员math、eng1ish存放数学和英语成绩。一个6参构造方法、一个两参构造方法、一个无参构造方法和重写输出方法用于显示6种属性
建立一个person类和一个Student类，功能如下叙述
ZFC.卡农的博客
05-08 1万+
/*功能（1）poerson中包含 name addr  sex  age ,设置一个输出方法talk()来显示这四个属性；（2）student类继承person类，并增加math English存放数学 英语成绩，用一个六参构造方法、一个两参构造方法，             一个无参构造方法和重写输出方法talk()用于显示六种属性*/package Extends;//父类对象personp...
java中person作用_Java题目：建立一个人类(Person)和学生类(Student) 功能要求：
weixin_36450655的博客
03-07 3438
满意答案lialei12017.11.25采纳率：48%等级：12已帮助：14031人package test;/*** Person中包含4个保护型的数据成员name,addr, sex,age分别为字符串，字符串，字符及整型。表示：姓名、地址、性别和年龄。一个四参构造函数，一个两参构造函数，一个无参构造函数，一个输出函数用于显示四种属性。* @author Administrator*...
编写出一个通用的人员类（Person），该类具有姓名（Name）、年龄（Age）、性别（Sex）等域。然后对Person 类的继承得到一个学生类（Student），该类能够存放学生的5门课的成绩，并能
热门推荐
qq_36055407的博客
07-24 3万+
编写出一个通用的人员类（Person），该类具有姓名（Name）、年龄（Age）、性别（Sex）等域。然后对Person 类的继承得到一个学生类（Student），该类能够存放学生的5门课的成绩，并能求出平均成绩。最后在Main函数中对student类的功能进行验证。 public class Demo02 { @Test public void test() { Student s_...
Java面向对象进阶-封装、继承、多态
AnswerCoder的博客
10-16 1206
Java面向对象进阶 1.static关键字 static表示“静态”的意思，可以用来修饰成员变量和成员方法。 static的主要作用在于创建独立于具体对象的域变量或者方法 简单理解： ​ 被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。 并且不会因为对象的多次创建而在内存中建立多份数据 注意 静态成员在类加载时加载并初始化。 无论一个类存在多少个对象 , 静态的属性, 永远在内存中只有一份(可以理解为所有对象公用 ) 在访问时：静态不能访
头歌平台Java实验：Java面向对象 - 封装、继承和多态
jing13_13的博客
04-29 2839
就是隐藏对象的属性和实现细节，仅对外提供公共访问方式。对于封装而言，一个对象它所封装的是自己的属性和方法，所以它是不需要依赖其他对象就可以完成自己的操作。良好的封装能够减少耦合。类内部的结构可以自由修改。可以对成员进行更精确的控制。隐藏信息，实现细节。封装把一个对象的属性私有化，同时提供一些可以被外界访问属性的方法，如果不想被外界访问，我们大可不必提供方法给外界访问。但是如果一个类没有提供给外界访问的方法，那么这个类也没有什么意义了。编程要求根据提示，在右侧编辑器Begin-End。
Java进阶01-封装、继承与多态
m0_67402096的博客
08-01 380
面向对象编程的优势:面向对象的程序设计有三大特征：封装、继承、多态。封装性有两重含义，一是指把对象的属性和行为看成一个密不可分的整体，将这两者“封装”到一个不可分割的对象中；二是指对信息的隐蔽，尽可能隐蔽对象的功能实现细节。 封装机制的另一个特点就是为封装在一个整体内的变量及方法规定不同等级的“可见性”或访问权限。封装的好处： 1）良好的封装能够减少耦合 2）类内部的结构可以自由修改。 3）可以对成员进行更精确的控制。 4）隐藏信息，实现细节。继承是为了重用父类代码。两个类若存在is-a 的关系就可以使用继
Educoder题目：Java面向对象 - 封装、继承和多态答案解析.md
11-08
Educoder题目：Java面向对象 - 封装、继承和多态答案解析
Java面向对象编程（封装/继承/多态）实例解析
08-29
Java 面向对象编程（封装/继承/多态）实例解析 Java 面向对象编程是一种编程范式，它强调对象之间的交互和继承关系。在 Java 中，面向对象编程主要体现在三大特征：封装、继承和多态。 封装是指隐藏对象的内部细节...
Java编程实训 Java开发基础入门教程1-06 面向对象编程-继承和多态（共28页）.ppt
12-25
面向对象编程是Java的核心特性之一，它通过封装、继承和多态这三大概念来构建复杂的软件系统。在Java编程实训中，"面向对象编程-继承和多态"这部分内容主要探讨了如何通过继承来减少代码冗余，提高代码的可复用性，...
头歌--Java面向对象 - 封装、继承和多态的综合练习
m0_56638814的博客
04-13 1万+
头歌--Java面向对象 - 封装、继承和多态的综合练习
Spring Boot 学习和使用
cesske的博客
09-24 673
Spring Boot是一款开源的Java Web应用框架，旨在简化Spring应用的初始搭建以及开发过程。Spring Boot通过整合Spring技术栈中的诸多关键组件，为开发者提供了一种快速、简便的Spring应用开发方式。它遵循“约定优于配置”的原则，通过自动配置、起步依赖和内置的Servlet容器，极大地简化了传统Spring应用的配置和部署过程。Spring Boot通过其自动化配置、起步依赖、内嵌服务器等特性，极大地简化了Spring应用的开发和部署过程。
基于JavaWeb开发的Java+SpringMvc+vue+element实现驾校管理系统详细设计
最新发布
央顺科技官方博客
09-24 542
机遇与挑战始终并存。在开放的互联网平台面前，驾校预约管理系统的信息管理面临着巨大的挑战。传统的管理模式局限于简单数据的管理，无法适应不断变化的市场格局。在早期阶段，在将计算机技术和网络技术融入驾校预约管理系统数据管理方法之前，所有管理方式都通过人工操作完成了管理信息的。系统管理也都将通过计算机进行整体智能化操作，对于驾校预约管理系统所牵扯的管理及数据保存都是非常多的，举例像所有详细信息包括，管理员；首页、个人中心、学员管理、驾校教练管理、驾校车辆管理、预约管理、取消预约管理、驾校公告管理、系统管理。
JDK17新增语法特性
2201_76124988的博客
09-20 766
从springboot3.0开始，已经不支持JDK8，转变为JDK17参考资料：官方博客。
Java Alibaba Druid 数据库连接池
miracle的专栏
09-24 508
在Java开发中，数据库连接池是性能优化的重要一环。而作为一款强大的数据库连接池解决方案，凭借其和对多种数据库的支持，成为了许多企业级应用的首选。本篇文章将介绍Druid的核心特性，并结合不同数据库的实际用法。
faiss安装 （CPU版本）
CSDN_WHB的博客
09-20 280
faiss版本 faiss-v1.7.4。
Mybatis-plus进阶篇(四)
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
09-19 1417
nested 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于创建一个独立的查询条件块，不带默认的 AND 或 OR 逻辑。last 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它允许你直接在查询的最后添加一个 SQL 片段，而不受 MyBatis-Plus 的查询优化规则影响。exists 方法是 MyBatis-Plus 中用于构建查询条件的高级方法之一，它用于在查询中添加一个 EXISTS 子查询。这个方法特别适用于需要对数值字段进行减量操作的场景。
《二哥的Java进阶之路》- 通俗易懂的Java学习指南
1. **Java基础知识**：这部分内容可能包括变量、数据类型、控制流、类与对象、封装、继承、多态等基础概念。对于新手来说，掌握这些基本概念和语法是必要的。 2. **Java并发编程**：并发是Java中的一个高级主题，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值