Java全栈JavaSE：13.面向对象中

Posted new nm个对象

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java全栈JavaSE：13.面向对象中相关的知识，希望对你有一定的参考价值。

一.封装

1.1 封装概述

1、为什么需要封装？

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

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

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

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

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

2、如何实现封装呢？

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

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

（1）类

（2）包

（3）子类

（4）模块：Java9之后引入

权限修饰符

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

修饰符本类本包其他包子类其他包非子类
private：私有的√×××
缺省√√××
protected：受保护的√√√×
public：公共的√√√√

外部类：只能使用public和缺省权限修饰符

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

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

示例一：本包非子类与子类
package com.atguigu.test01.access1;

public class Father {
	public int a;
	protected int b;
	int c;
	private int d;
	
	public static int e;
	protected static int f;
	static int g;
	private static int h;
}


class Mother{
	public Mother(){
		
	}
}

package com.atguigu.test01.access1;

//本包非子类中
public class Other {
	public static void method(){
		Father obj = new Father();
		System.out.println(obj.a);
		System.out.println(obj.b);
		System.out.println(obj.c);
//		System.out.println(obj.d);//跨类不可见
		
		System.out.println(Father.e);
		System.out.println(Father.f);
		System.out.println(Father.g);
//		System.out.println(h);//跨类不可见
	}
	
	public void fun(){
		Father obj = new Father();
		System.out.println(obj.a);
		System.out.println(obj.b);
		System.out.println(obj.c);
//		System.out.println(obj.d);//跨类不可见
		
		System.out.println(Father.e);
		System.out.println(Father.f);
		System.out.println(Father.g);
//		System.out.println(h);//跨类不可见
	}
}


package com.atguigu.test01.access1;

//本包子类中
public class Sub extends Father{
	public static void method(){
		//静态直接访问非静态都不行
/*		System.out.println(a);
		System.out.println(b);
		System.out.println(c);
		System.out.println(d);*/
		
		Father obj = new Father();
		System.out.println(obj.a);
		System.out.println(obj.b);
		System.out.println(obj.c);
//		System.out.println(obj.d);//跨类不可见
		
		System.out.println(e);
		System.out.println(f);
		System.out.println(g);
//		System.out.println(h);//跨类不可见
	}
	
	public void fun(){
		System.out.println(a);
		System.out.println(b);
		System.out.println(c);
//		System.out.println(d);//跨类不可见
		
		System.out.println(e);
		System.out.println(f);
		System.out.println(g);
//		System.out.println(h);//跨类不可见
	}
}

示例二：跨包子类和非子类
package com.atguigu.test01.access1;

public class Father {
	public int a;
	protected int b;
	int c;
	private int d;
	
	public static int e;
	protected static int f;
	static int g;
	private static int h;
}


package com.atguigu.test01.other;

import com.atguigu.test01.access1.Father;

public class Another {
	public static void method(){
		Father obj = new Father();
		System.out.println(obj.a);
//		System.out.println(obj.b);//跨包非子类不可见
//		System.out.println(obj.c);//跨包不可见
//		System.out.println(obj.d);//跨类不可见
		
		System.out.println(Father.e);
//		System.out.println(Father.f);//跨包非子类不可见
//		System.out.println(Father.g);//跨包不可见
//		System.out.println(h);//跨类不可见
	}
	
	public void fun(){
		Father obj = new Father();
		System.out.println(obj.a);
//		System.out.println(obj.b);//跨包非子类不可见
//		System.out.println(obj.c);//跨包不可见
//		System.out.println(obj.d);//跨类不可见
		
		System.out.println(Father.e);
//		System.out.println(Father.f);//跨包非子类不可见
//		System.out.println(Father.g);//跨包不可见
//		System.out.println(h);//跨类不可见
	}
}


package com.atguigu.test01.other;

import com.atguigu.test01.access1.Father;

public class Son extends Father{
	public static void method(){
		//静态直接访问非静态都不行
/*		System.out.println(a);
		System.out.println(b);
		System.out.println(c);
		System.out.println(d);*/
		
		Father obj = new Father();
		System.out.println(obj.a);
//		System.out.println(obj.b);//跨包的静态成员
						//不能访问非静态的protected
//		System.out.println(obj.c);//跨包不可见
//		System.out.println(obj.d);//跨类不可见
		
		System.out.println(e);
		System.out.println(f);
//		System.out.println(g);//跨包不可见
//		System.out.println(h);//跨类不可见
	}
	
	public void fun(){
		System.out.println(a);
		System.out.println(b);
//		System.out.println(c);//跨包不可见
//		System.out.println(d);//跨类不可见
		
		System.out.println(e);
		System.out.println(f);
//		System.out.println(g);//跨包不可见
//		System.out.println(h);//跨类不可见
	}
}

示例三：缺省的类
package com.atguigu.test01.access1;

class Mother {
	
}

package com.atguigu.test01.access1;

public class Daughter extends Mother{

}

package com.atguigu.test01.other;

//Mother类是缺省的，跨包不能使用
public class Daughter extends Mother{

}

示例四：公共的类缺省的构造器，跨包使用问题
package com.atguigu.test01.access1;

public class Fu {
	Fu(){
		
	}
}

package com.atguigu.test01.access1;

public class Zi extends Fu{

}

package com.atguigu.test01.other;

import com.atguigu.test01.access1.Fu;

public class Zi extends Fu{
	Zi() {
		super();
	}
}

package com.atguigu.test01.access1;

public class Neighbor {
	public static void main(String[] args) {
		Fu f = new Fu();
	}
}

package com.atguigu.test01.other;

import com.atguigu.test01.access1.Fu;

public class AnotherNeighbor {
	public static void main(String[] args) {
		Fu f = new Fu();
	}
}

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

  • 我们在定义类的成员变量时，往往会将其设置为私有的属性（private）。防止外界直接给属性随意赋值，因为外部赋值时只需要满足语法即可。而实际项目开发时，不仅要满足语法，还需要满足业务逻辑。

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

1、成员变量封装的目的

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

2、实现步骤

  1. 使用 private 修饰成员变量
private 数据类型 变量名 ；

代码如下：

public class Chinese {
    private static String country;
    private String name;
  	private int age;
    private boolean marry;
}
  1. 提供 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;
    }
}

4、 练习

（1）定义矩形类Rectangle，

​ 声明静态变量sides，初始化为4，表示矩形边长的总数量；

​ 声明实例变量长和宽

​ 全部私有化，并提供相应的get/set方法

（2）在测试类中创建Rectangle对象，并调用相应的方法测试

实现矩形类Rectangle的定义：

package com.oy.面向对象.封装;

public class Rectangle {
    public static int sides = 4;
    private int length;
    private int width;
    
    public void setLength(int length){
        this.length = length;
    }
    public int getLength(){
        return this.length;
    }
    
    public void setWidth(int width){
        this.width = width;
    }
    
    public int getWidth(){
        return this.width;
    }
}

在测试类中创建Rectangle对象，并调用相应的方法测试

package com.oy.面向对象.封装;

public class Demotest1 {
    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle();
        rectangle.setLength(8);
        System.out.println("矩形长度为："+rectangle.getLength());
        rectangle.setWidth(10);
        System.out.println("矩形的宽度为："+rectangle.getWidth());
    }
}

运行结果如下：

矩形长度为：8
矩形的宽度为：10

二.构造器或构造方法（Constructor)

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

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

2.1、构造器的作用

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

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

2.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;
	}
}

注意事项：

  1. 构造器名必须与它所在的类名必须相同。
  2. 它没有返回值，所以不需要返回值类型，甚至不需要void
  3. 如果你不提供构造器，系统会给出无参数构造器，并且该构造器的修饰符默认与类的修饰符相同
  4. 如果你提供了构造器，系统将不再提供无参数构造器，除非你自己定义。
  5. 构造器是可以重载的，既可以定义参数，也可以不定义参数。也可以定义部分参数
  6. 构造器的修饰符只能是权限修饰符，不能被其他任何修饰

2.3、练习

（1）声明一个员工类，

  • 包含属性：编号、姓名、薪资、性别，要求属性私有化，提供get/set，
  • 提供无参构造器和有参构造器
  • 提供getInfo()

（2）在测试类的main中分别用无参构造和有参构造创建员工类对象，调用getInfo

public class TestEmployee {
	public static void main(String[] args){
		//分别用无参构造和有参构造创建对象，调用getInfo
		Employee e1 = new Employee();
		System.out.println(e1.getInfo());
		
		Employee e2 = new Employee("1001","张三",110000,'男');
		System.out.println(e2.getInfo());
		
		e2.setSalary(120000);
		System.out.println(e2.getInfo());
		
		System.out.println("e1薪资：" + e1.getSalary());
	Java全栈JavaSE：14.面向对象下


 Java全栈学习路线


 JavaSE入门学习13：Java面向对象之封装


 我的全栈之路-Java架构师技术栈


 如何通过单击适配器类中代码的项目中的删除按钮来删除列表视图中的项目后重新加载片段？


 Java全栈JavaSE：21.集合之Map