封装概述

为什么需要封装，封装的作用和含义，请举例？
- 我要用洗衣机，只需要按一下开关和洗涤模式就可以了，有必要了解洗衣机的内部结构吗？有必要碰电动机吗？...答案是不需要的。
程序设计追求“高内聚，低耦合”
- 高内聚：类的内部数据操作细节自己完成，不允许外部干涉
- 低耦合：仅对外暴露少量的方法用于使用。
定义：隐藏对象的内部复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的课扩展性，可维护性。
通俗讲：把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装的设计思想。

封装性的体现实例

我们将类的属性私有化（private），同时提供公共的（public）的调用(getXxx)和设置（setXxx）的方法。

/**
 * 封装性的体现
 * 
 * @author Administrator
 *
 */
public class PackageTest {
	public static void main(String[] args) {
		Animal ani = new Animal();
		ani.age = 3;
//		ani.legs = 4;
		ani.name = "大花";
		System.out.println(ani.name);
		ani.eat();

		// 成员变量第一只能控制数据类型（int 等）或者权限（public 等）
		// 举例子，动物的腿不能设置为小于0的，而且只能是偶数
		// 所以我们要控制，就是通过封装性，写一个setLegs()的方法进行控制
//		ani.setLegs(-1);
//		System.out.println(ani.legs);//0
//		ani.setLegs(3);
//		System.out.println(ani.legs);//0
		ani.setLegs(4);
//		System.out.println(ani.legs);//4
		// 但是问题又来了，用户还是可以直接调用legs属性
//		ani.legs = -4;
		// 所以我们要将legs属性设置为私有的private
		// 设置完毕后发现legs不能获取了，所以我们要设置获取的方法getLegs
		System.out.println(ani.getLegs());
	}
}

class Animal {
	int age;
	String name;
	private int legs;

	public void eat() {
		System.out.println(name + "在进食");
	}

	/**
	 * 设置方法
	 * 
	 * @param i 腿的数量
	 */
	public void setLegs(int i) {
		if (i < 0 || i % 2 != 0) {
			legs = 0;
			// 目前没有学到抛出异常，暂时用0代替
		} else {
			legs = i;
		}
	}

	/**
	 * 获取方法
	 * 
	 * @return 返回腿的数量
	 */
	public int getLegs() {
		return legs;
	}
}

20200804145843

注意

以上内容只是封装性的体现之一，封装性的体现还有很多，比如：

单例模式
方法私有
等

权限修饰符

java四种权限修饰符

private
缺省(default)
protected
public

四种权限可以修饰：

属性
方法
构造器
内部类

四种访问权限

修饰符	类内部	同一个包	不同包的子类	同一个工程
private	Yes
缺省	Yes	Yes
protected	Yes	Yes	Yes
public	Yes	Yes	Yes	Yes

注意

class的修饰只能使用public或缺省
public类可以在工程任意地方访问。
defalut类只可以在同一个包内部的类访问。

构造方法

构造方法 = 构造器 = constructor

构造器的作用

创建对象
在创建对象的过程中给属性赋值

说明：

当类中没有显式的构造器，系统会默认提供一个空参构造器。
构造器的格式：权限修饰符类名(参数列表){方法体}
一个类中定义的多个构造器，彼此构成了重载
当存在显式的构造器后，系统不再提供默认的空参构造器，需要自己手动创建空参构造器。
系统默认构造器的权限，是根类的权限一样的，public或缺省

实例

public class ConstructorTest {
	public static void main(String[] args) {
		// Person()，就是一个空参构造器
		Person p = new Person();
		//构造器作用2：赋值
		Person p1 = new Person("Tom",18);
		System.out.println(p1.name);
	}
}

class Person {
	String name;
	int age;

	// 显式空参构造器
	public Person() {
		System.out.println("Person()");
	}

	public Person(String n, int a) {
		name = n;
		age = a;
	}
}

其他知识点

赋值的先后顺序

默认初始化
显式初始化
构造器赋值
通过“对象.方法”过“对象.属性”的方式，赋值
以上操作的先后顺序：1→2→3→4，123操作只可以执行一次，4可以反复执行。

JavaBean

是一种Java语言写成的可重用组件。

JavaBean的标准：
1. 类是公共的
2. 有一个无参的公共的构造器
3. 有属性，且有对应的get、set方法

关键字：this

this表示当前对象，可以调用类的属性、方法和构造器。
通常情况下，可以省略this，特殊情况下，如果方法的形参和属性同名时候，我们必须使用this.变量的方式，表明变量是属性，非形参。
可以使用this(参数)调用构造器，在构造器内调用其他构造器，不能调用自己。
在构造器内调用其他构造器时，this(形参列表)必须声明在当前构造器的首行。
构造器内部，最多只能声明一个this构造器

实例

boy 类

public class Boy {
	private String name;
	private int age;

	public Boy() {
	}

	public Boy(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;
	}

	public void marry(Girl girl) {
		System.out.println("我想娶" + girl.getName());
	}

	public void shout() {
		if (this.age >= 22) {
			System.out.println("我可以结婚了");
		} else {
			System.out.println("多谈几年恋爱");
		}
	}

}

girl类

public class Girl {
	private String name;
	private int 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;
	}

	public void marry(Boy boy) {
		System.out.println("我想嫁给" + boy.getName());
		// this，当前类对象
		boy.marry(this);
	}
	
	//比较大小
	//返回正数，当前类对象大，负数形参对象大，0一样大
	public int compare(Girl girl) {
		return this.age - girl.age;
	}
}

测试类

public class Test {
	public static void main(String[] args) {
		Boy boy = new Boy("梁山伯",22);
		Girl girl = new Girl();
		girl.setAge(18);
		girl.setName("祝英台");
		
		boy.shout();
		boy.marry(girl);
		System.out.println("---------");
		girl.marry(boy);
		System.out.println("---------");
		Girl g = new Girl();
		g.setAge(19);
		g.setName("朱丽叶");
		int compare  = girl.compare(g);
		System.out.println(compare);
	}
}

关键字：package

为了更好地实现项目中的类的管理，提供包的概念。
使用package声明类或接口所在的位置，声明在源文件首行。
包，属于标识符，遵循命名规则和规范（xxx.yyy.zzz）
每一个点（xxx.yyy.zzz），都是一层目录
同一个包下，不能命名同名的接口、类。反之可以。

MVC设计模式

将整个程序分为三个层次，视图模型层，控制器层，数据模型层。

关键字：import

作用：导入

在源文件中显式使用import结构导入指定包下的类、接口等
声明在package和类的声明之间。
如果使用的类或接口是java.lang，可以省略import
如果使用的类或接口是本包下的，可以省略import
使用了不同包下的同名的类，只要有一个类需要使用全类名的方式显式。
import static：导入指定类或接口中的静态结构。

Day10问题

构造器的作用是什么？使用中有哪些注意点（>=3条）
- 作用：
  - 创建对象。
  - 初始化对象的结构。
- 注意点：
  - 没有创建构造器，系统会默认提供一个空参的构造器。
  - 创建了构造器，系统默认的空参构造器不在提供，需要自己创建空参的构造器。
  - 构造器可以重载。
  - 构造器没有返回值。
  - 系统默认构造器的权限，跟类的权限是一样的。
  - 构造器格式：权限修饰符类名(形参列表){方法体}
关于类的属性的赋值，有几种赋值方式。谈谈赋值的先后顺序。
- 赋值方式：
  - 默认初始化
  - 通过显式初始化
  - 构造器初始化值
  - 方法调用
- 顺序：由上而下。
this关键字可以用来调用哪些结构，简单说明一下其使用。
- 调用结构：
  - 属性
  - 方法
  - 构造器
- this是当前类对象，在方法中如果局部变量名称与成员变量名称参数一样，可以通过this.名称调用成员变量。
java中目前涉及到的四中权限修饰符都有什么？并说明各自的范围。
- private：类内使用。
- 缺省：类内、同一个包下使用。
- protected:类内、同一个包下、不同包继承下使用
- public：整个工程内部都可以使用
创建Circle类，提供私有的属性radius，提供相应的get/set方法，提供求圆面积的方法。

import org.junit.Test;

public class Circle {
private int radius;

public void setRadius(int radius) {
	this.radius = radius;
}

public int getRadius() {
	return this.radius;
}

public double getPI() {
	return Math.PI * this.radius * radius;
}

@Test
public void Test() {
	Circle c = new Circle();
	c.setRadius(10);
	double d = c.getPI();
	System.out.println(d);
}

}

![20200805150443](https://md-1252557811.cos.ap-nanjing.myqcloud.com/note/20200805150443.png)

本文由 Gorrywang 创作，严禁转载与复制！
最后编辑时间为: Aug 5,2020

面向对象_封装与构造器