Java--面向对象基础封装继承多态

Posted 2022-11-28 白发随你去

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java--面向对象基础封装继承多态相关的知识，希望对你有一定的参考价值。

1 封装

1.1 封装概述

1、为什么需要封装？

我要用洗衣机，只需要按一下开关和洗涤模式就可以了。有必要了解洗衣机内部的结构吗？有必要碰电动机吗？
我们使用的电脑，内部有CPU、硬盘、键盘、鼠标等等，每一个部件通过某种连接方式一起工作，但是各个部件之间又是独立的
现实生活中，每一个个体与个体之间是有边界的，每一个团体与团体之间是有边界的，而同一个个体、团体内部的信息是互通的，只是对外有所隐瞒。

面向对象编程语言是对客观世界的模拟，客观世界里每一个事物的内部信息都是隐藏在对象内部的，外界无法直接操作和修改，只能通过指定的方式进行访问和修改。封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。

随着我们系统越来越复杂，类会越来越多，那么类之间的访问边界必须把握好，面向对象的开发原则要遵循“高内聚、低耦合”，而“高内聚，低耦合”的体现之一：

高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
低耦合：仅对外暴露少量的方法用于使用

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的讲，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

2、如何实现封装呢？

通俗的讲，封装就是把该隐藏的隐藏起来，该暴露的暴露出来。那么暴露的程度如何控制呢？就是依赖访问控制修饰符，也称为权限修饰符来控制。

访问控制修饰符来控制相应的可见边界，边界有如下：

（1）类

（2）包

（3）子类

（4）模块：Java9之后引入

权限修饰符

权限修饰符：public,protected,缺省,private

修饰符	本类	本包	其他包子类	其他包非子类
private	√	×	×	×
缺省 default	√	√	×	×
protected	√	√	√	×
public	√	√	√	√

外部类：public和缺省

成员变量、成员方法、构造器、成员内部类：public,protected,缺省,private

提示：protected修饰非静态成员，**跨包时，**只能在子类的非静态成员中访问，在静态成员中无论是否创建对象都不能访问。

1.2 成员变量/属性私有化问题

**成员变量（field）私有化之后，提供标准的get/set方法，我们把这种成员变量也称为属性（property）。**或者可以说只要能通过get/set操作的就是事物的属性，哪怕它没有对应的成员变量。

1、成员变量封装的目的

隐藏类的实现细节
让使用者只能通过事先预定的方法来访问数据，从而可以在该方法里面加入控制逻辑，限制对成员变量的不合理访问。还可以进行数据检查，从而有利于保证对象信息的完整性。
便于修改，提高代码的可维护性。主要说的是隐藏的部分，在内部修改了，如果其对外可以的访问方式不变的话，外部根本感觉不到它的修改。例如：Java8->Java9，String从char[]转为byte[]内部实现，而对外的方法不变，我们使用者根本感觉不到它内部的修改。

2、实现步骤

使用 private 修饰成员变量

private 数据类型 变量名 ；

代码如下：
2. 提供 getXxx方法 / setXxx 方法，可以访问成员变量，代码如下：

public class Chinese 
  	private static String country;
    private String name;
  	private int age;
    private boolean marry;
    
    public static void setCountry(String c)
        country = c;
    
    
    public static String getCountry()
        return country;
    

	public void setName(String n) 
		name = n;
    

    public String getName() 
        return name;
	

    public void setAge(int a) 
        age = a;
    

    public int getAge() 
        return age;
    
    
    public void setMarry(boolean m)
        marry = m;
    
    
    public boolean isMarry()
        return marry;

3、如何解决局部变量与成员变量同名问题

当局部变量与类变量（静态成员变量）同名时，在类变量前面加“类名."；

当局部变量与实例变量（非静态成员变量）同名时，在实例变量前面加“this.”

public class Chinese 
  	private static String country;
    private String name;
  	private int age;
    
    public static void setCountry(String country)
        Chinese.country = country;
    
    
    public static String getCountry()
        return country;
    

	public void setName(String name) 
		this.name = name;
    

    public String getName() 
        return name;
	

    public void setAge(int age) 
        this.age = age;
    

    public int getAge() 
        return age;

2 构造器（Constructor)

我们发现我们new完对象时，所有成员变量都是默认值，如果我们需要赋别的值，需要挨个为它们再赋值，太麻烦了。我们能不能在new对象时，直接为当前对象的某个或所有成员变量直接赋值呢。

可以，Java给我们提供了构造器。

1、构造器的作用

在创建对象的时候为实例变量赋初始值。

注意：构造器只为实例变量初始化，不为静态类变量初始化

2、构造器的语法格式

构造器又称为构造方法，那是因为它长的很像方法。但是和方法还有有所区别的。

【修饰符】 构造器名()
    // 实例初始化代码

【修饰符】 构造器名(参数列表)
	// 实例初始化代码

代码如下：

public class Student 
	private String name;
	private int age;
	// 无参构造
  	public Student()  
 	// 有参构造
  	public Student(String name,int age) 
		this.name = name;
    	this.age = age; 
	
  	
	public String getName() 
		return name;
	
	public void setName(String name) 
		this.name = name;
	
	public int getAge() 
		return age;
	
	public void setAge(int age) 
		this.age = age;

注意事项：

构造器名必须与它所在的类名必须相同。
它没有返回值，所以不需要返回值类型，甚至不需要void
如果你不提供构造器，系统会给出无参数构造器，并且该构造器的修饰符默认与类的修饰符相同
如果你提供了构造器，系统将不再提供无参数构造器，除非你自己定义。一旦声明了一个有参的构造器那么默认无参构造器消失。

注意：每创建一个类，都去提供一个默认的无参构造器；

构造器是可以重载的，既可以定义参数，也可以不定义参数。
构造器的修饰符只能是权限修饰符，不能被其他任何修饰。
构造器的参数名要与成员变量名一致见名知意。使用this区分成员变量和局部变量。

3 标准JavaBean

JavaBean 是 Java语言编写类的一种标准规范。符合JavaBean 的类，要求：

（1）类必须是具体的和公共的，

（2）并且具有无参数的构造方法，

（3）成员变量私有化，并提供用来操作成员变量的set 和get 方法。

public class ClassName
  //成员变量
    
  //构造方法
  	//无参构造方法【必须】
  	//有参构造方法【建议】
  	
  //getXxx()
  //setXxx()
  //其他成员方法

编写符合JavaBean 规范的类，以学生类为例，标准代码如下：

public class Student 
	// 成员变量
	private String name;
	private int age;

	// 构造方法
	public Student() 
	

	public Student(String name, int age) 
		this.name = name;
		this.age = age;
	

	// get/set成员方法
	public void setName(String name) 
		this.name = name;
	

	public String getName() 
		return name;
	

	public void setAge(int age) 
		this.age = age;
	

	public int getAge() 
		return age;
	
    
    //其他成员方法列表
    public String getInfo()
        return "姓名：" + name + "，年龄：" + age;

测试类，代码如下：

public class TestStudent 
	public static void main(String[] args) 
		// 无参构造使用
		Student s = new Student();
		s.setName("柳岩");
		s.setAge(18);
		System.out.println(s.getName() + "---" + s.getAge());
        System.out.println(s.getInfo());

		// 带参构造使用
		Student s2 = new Student("赵丽颖", 18);
		System.out.println(s2.getName() + "---" + s2.getAge());
        System.out.println(s2.getInfo());

4 继承

4.1 继承的概述

继承的由来

如图所示：

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类中无需再定义这些属性和行为，只需要和抽取出来的类构成某种关系。如图所示：

其中，多个类可以称为子类，也叫派生类；多个类抽取出来的这个类称为父类、超类（superclass）或者基类。

继承描述的是事物之间的所属关系，这种关系是：is-a 的关系。例如，图中猫属于动物，狗也属于动物。可见，父类更通用，子类更具体。我们通过继承，可以使多种事物之间形成一种关系体系。

继承的好处

提高代码的复用性。
提高代码的扩展性。
类与类之间产生了关系，是学习多态的前提。

4.2 继承的格式

通过 extends 关键字，可以声明一个子类继承另外一个父类，定义格式如下：

【修饰符】 class 父类 
	...


【修饰符】 class 子类 extends 父类 
	...

4.3 继承的特点一：成员变量

1、父类成员变量私有化（private）

父类中的成员，无论是公有(public)还是私有(private)，均会被子类继承。
子类虽会继承父类私有(private)的成员，但子类不能对继承的私有成员直接进行访问，可通过继承的get/set方法进行访问。如图所示：

2、父子类成员变量重名

我们说父类的所有成员变量都会继承到子类中，那么如果子类出现与父类同名的成员变量会怎么样呢？

父类代码：

public class Father 
	public int i=1;
	private int j=1;
	public int k=1;
	public int getJ() 
		return j;
	
	public void setJ(int j) 
		this.j = j;

子类代码：

public class Son extends Father
	public int i=2;
	private int j=2;
	public int m=2;

现在想要在子类Son中声明一个test()方法，并打印这些所有变量的值，该如何实现？

public class Son extends Father
	public int i=2;
	private int j=2;
	public int m=2;
	
	public void test() 
		System.out.println("父类继承的i：" + super.i);
		System.out.println("子类的i：" +i);
//		System.out.println(super.j);
		System.out.println("父类继承的j：" +getJ());
		System.out.println("子类的j：" +j);
		System.out.println("父类继承的k：" +k);
		System.out.println("子类的m：" +m);

结论：

（1）当父类的成员变量私有化时，在子类中是无法直接访问的，所以是否重名不影响，如果想要访问父类的私有成员变量，只能通过父类的get/set方法访问；

（2）当父类的成员变量非私有时，在子类中可以直接访问，所以如果有重名时，就需要加“super."进行区别。

使用格式：

super.父类成员变量名

以上test()调用结果：

public class TestSon
	public static void main(String[] args)
		Son s = new Son();
		s.test();

父类继承的i：1
子类的i：2
父类继承的j：1
子类的j：2
父类继承的k：1
子类的m：2

说明：虽然我们可以区分父子类的重名成员变量，但是实际开发中，我们不建议这么干。

4.4 继承的特点二：成员方法

我们说父类的所有方法子类都会继承，但是当某个方法被继承到子类之后，子类觉得父类原来的实现不适合于子类，该怎么办呢？我们可以进行方法重写 (Override)

1、方法重写

比如新的手机增加来电显示头像的功能，代码如下：

class Phone 
	public void sendMessage()
		System.out.println("发短信");
	
	public void call()
		System.out.println("打电话");
	
	public void showNum()
		System.out.println("来电显示号码");
	


//智能手机类
class NewPhone extends Phone 
	
	//重写父类的来电显示号码功能，并增加自己的显示姓名和图片功能
	public void showNum()
		//调用父类已经存在的功能使用super
		super.showNum();
		//增加自己特有显示姓名和图片功能
		System.out.println("显示来电姓名");
		System.out.println("显示头像");
	


public class ExtendsDemo06 
	public static void main(String[] args) 
      	// 创建子类对象
      	NewPhone np = new NewPhone()；
        
        // 调用父类继承而来的方法
        np.call();
      
      	// 调用子类重写的方法
      	np.showNum();

小贴士：这里重写时，用到super.父类成员方法，表示调用父类的成员方法。

注意事项：

1.@Override：写在方法上面，用来检测是不是有效的正确覆盖重写。这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。建议保留

2.必须保证父子类之间方法的名称相同，参数列表也相同。
3.子类方法的返回值类型必须【小于等于】父类方法的返回值类型（小于其实就是是它的子类，例如：Student < Person）。

注意：如果返回值类型是基本数据类型和void，那么必须是相同

4.子类方法的权限必须【大于等于】父类方法的权限修饰符。
小扩展提示：public > protected > 缺省 > private

5.几种特殊的方法不能被重写

静态方法不能被重写
私有等在子类中不可见的方法不能被重写
final方法不能被重写

2、方法的重载

（1）同一个类中

class Test
	public int max(int a, int b)
		return a > b ? a : b;
	
	public double max(double a, double b)
		return a > b ? a : b;
	
	public int max(int a, int b,int c)
		return max(max(a,b),c);

（2）父子类中

class Father
	public void print(int i)
		System.out.println("i = " + i);
	

class Son extends Father
	public void print(int i,int j)
		System.out.println("i = " + i  ",j = " + j);

对于Son类，相当于有两个print方法，一个形参列表是(int i)，一个形参列表(int i, int j)

4.5 继承的特点三：构造方法

当类之间产生了关系，其中各类中的构造方法，又产生了哪些影响呢？

首先我们要回忆两个事情，构造方法的定义格式和作用。

构造方法的名字是与类名一致的。

所以子类是无法继承父类构造方法的。
构造方法的作用是初始化实例变量的，而子类又会从父类继承所有成员变量

所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个super() ，表示调用父类的实例初始化方法，父类成员变量初始化后，才可以给子类使用。

如果父类没有无参构造怎么办？

public class Person 
	private String name;
	private int age;
	public Person(String name, int age) 
		this.name = name;
		this.age = age;
	
	//其他成员方法省略

public class Student extends Person
	private int score;

此时子类代码报错。

解决办法：在子类构造器中，用super(实参列表)，显示调用父类的有参构造解决。

public class Student extends Person
	private int score;

	public Student(String name, int age) 
		super(name, age);
	
	public Student(String name, int age, int score) 
		super(name, age);
		this.score = score;
	
	
	//其他成员方法省略

结论：

子类对象实例化过程中必须先完成从父类继承的成员变量的实例初始化，这个过程是通过调用父类的实例初始化方法来完成的。

super()：表示调用父类的无参实例初始化方法，要求父类必须有无参构造，而且可以省略不写；
super(实参列表)：表示调用父类的有参实例初始化方法，当父类没有无参构造时，子类的构造器首行必须写super(实参列表)来明确调用父类的哪个有参构造（其实是调用该构造器对应的实例初始方法）
super()和super(实参列表)都只能出现在子类构造器的首行

形式一：

class A
	A(int a)
		System.out.println("A类有参构造器");
	

class B extends A
	B()
		System.out.println("B类无参构造器");
	

class Test05
    public static void main(String[] args)
        B b = new B();
        //A类显示声明一个有参构造，没有写无参构造，那么A类就没有无参构造了
		//B类显示声明一个无参构造，        
		//B类的无参构造没有写super(...)，表示默认调用A类的无参构造
        //编译报错，因为A类没有无参构造

形式二：

class A
	A(int a)
		System.out.println("A类有参构造器");
	

class B extends A
	B(int a)
		super(a);
		System.out.println("B类有参构造器");
	

class Test07
    public static void main(String[] args)
        B b = new B(10);
        //A类显示声明一个有参构造，没有写无参构造，那么A类就没有无参构造了
		//B类显示声明一个有参构造，        
		//B类的有参构造明确写super(a)，表示调用A类的有参构造
        //会打印“A类有参构造器"和"B类有参构造器"

4.6 继承的特点四：单继承限制

Java只支持单继承，不支持多继承。

//一个类只能有一个父类，不可以有多个父类。
class C extends A 	//ok
class C extends A，B...	//error

Java支持多层继承(继承体系)。

class A
class B extends A
class C extends B

顶层父类是Object类。所有的类默认继承Object，
以上是关于Java--面向对象基础封装继承多态的主要内容，如果未能解决你的问题，请参考以下文章

1.2Java基础面向对象(类和对象概念封装继承多态)

Java--面向对象基础封装继承多态

Java面试题详解一：面向对象三大特性

java面向对象的基本形式,封装继承多态

JAVA面向对象，继承、封装、多态

Java语言简介基础组成封装继承多态抽象类内部类接口