2.封装思想

文章目录

一.package语句
二.import语句
三.static import语句
四.封装思想
五.访问权限修饰符
六.JavaBean规范
七.this关键字
八.构造器和setter方法选用
九.判断点和圆的关系

一.package语句

语法格式：package 包名.子包名.子子包名；
必须把该语句写入Java文件的第一行代码当中。
此时编译命令：javac -d . Hello.java;
如果此时Hello.java文件中没有使用package语句，表示在当前目录中生成字节码文件。
如果此时Hello.java文件中使用了package语句，此时表示在当前目录中先生成包名，
再在包中生成字节码文件。
运行命令：java 包名.类名;

![image][move]
8. 包名的定义
1. 包名必须遵循标识符规/全部小写，不能以java开头
2. 企业开发中，包名才有公司域名倒写。
假如企业的名字不符合规范，可以使用某些字符代替
格式：package 域名倒写.模块名.组建名
9. 类的名称
1. 类的简单名称：定义类的名称；如：PackageDemo.
2. 类的全限定名称：包名.类名；如：com.kun.huang.PackageDemo.
3. 在开发中先有package而后在package中在定义类。

![image][package]

Java(JDK)中的包：

![image][JDK]

二.import语句

没有使用import语句前，不再同一个包中的类，得使用全限定名来操作，

新建ImportDemo.java

class ImportDemo
{
	public static void main(String[] args) 
	{
		int[] arr = new int[]{1,2,8,90,4,5,6,7};
		//打印数组
		String ret = java.util.Arrays.toString(arr);
		System.out.println(ret);
	}
}

使用import语句，直接把某个包下的类导入当前类中，
语句格式：import 需要导入类的全限定名；只能导入某一个类
import 包名.子包名.*; 表示会引入该包下的所有的在当前文件中使用到的类。
import java.util.*; *为通配符，表示包名。
在Eclipse工具中，即时使用通配符*，在格式化代码的时候，会转换为N条import语句。

此后，在本java文件中，只需使用类的简单名称即可。

修改ImportDemo.java

import java.util.Arrays;
class ImportDemo
{
	public static void main(String[] args) 
	{
		int[] arr = new int[]{1,2,8,90,4,5,6,7};
		//打印数组
		String ret = java.util.Arrays.toString(arr);
		System.out.println(ret);

		//排序
		Arrays.sort(arr);
		ret = java.util.Arrays.toString(arr);
		System.out.println(ret);
	}
}

编译器会自动去java.lang包中去寻找使用到的类，但不会导入java.lang子包里面的类。

非String.lang包的类，都需要导入。

三.static import语句

调用静态方法时，不需要写类名，相当于自己的方法。

语法格式：

import static 类的全限定名.该类中的static成员名；
import sttatic java.util.Arrays.sort;

import static 类的全限定名.；此时的表示当前类的任意使用到的静态成员。
通过反编译工具，其实所谓的静态导入是一个编译器级别的新特性。
在实际开发中，不使用静态导入，因为如此，分不清某一个静态方法或字段来源于哪一个类。
Eclipse工具，当格式化代码的时候，将字段取消了所有的静态导入，变成使用类名调用。

四.封装思想

把对象的状态和行为看成一个统一的整体，将二者存放在一个独立的模块中（类）
“信息隐藏”，把不需要让外界知道的信息隐藏起来，尽可能隐藏对象功能实现细节。
暴露方法，
让外界安全访问功能。把所有的字段使用private私有化，public公共化允许外界访问。
把所有数据信息隐藏起来，尽可能的功能，只向外暴露便捷的方法，
以供调用。
封装的好处：
1. 使调用者正确，方便地使用系统功能，防止调用者随意修改系统属性。
2. 提高组件的重用性
3. 达到组件之间的低耦合（当某一个模块实现发生变化时，只要对外露的接口不变，就不会
  影响到其他模块）
4. 高内聚：把该模块的内部数据，功能细节隐藏在模块内部，不允许外界直接干预。
5. 低耦合：该模块只需要给外界暴露少量功能方法。

五.访问权限修饰符

访问权限控制：
private：表示私有的，表示类访问权限，只能在本类中访问，离开本类时，不能直接访问。
不写（缺省）：表示包私有，表示包访问权限，访问者的包必须和当前定义类的包相同才能访问。
protected：表示子类访问权限，同包中的可以访问，即使不同包，但是有继承关系，也可以访问。
public：表示全局的，可以公共访问权限，如某个字段/方法，使用了public修饰，则可以在项目
中任何地方访问。

![image][visit]

一般字段都使用private修饰，表达隐藏，为了安全性。
拥有实现细节的方法，一般使用private修饰，不希望外界（调用者）看到该方法的实现细节。
一般的，方法我们使用public修饰，供外界直接调用。

//直接暴露给外界，供调用者直接调用即可
public void doWork(){
methodA();
methodB();
methodC();
}
//仅仅只是完成了部分操作，不需要调用者调用
private methodA(){}
private methodB(){}
private menthodC(){}

一般的，我们不用缺省，即使用，也仅仅是暴露给同包中的其他类。
protected，一般在继承关系中，父类需要把一个方法只暴露给子类。

六.JavaBean规范

为可重用性组件。

遵循规范：
1. 必须使用public修饰
2. 必须保证有公共无参数构造器
3. 包含了属性的操作手段（给属性赋值，获取属性）
分类：
1. 复杂：UI，比如Button，Panel，Window类
2. 简单：domain，dao，service组件，封装数据，操作数据库，逻辑运算等。
  （封装有字段，并提供getter/setter,为boolean类型时不是get是is）
成员：
1. 方法：Method
2. 事件：event
3. 属性：property
属性：
1. attribute：表示状态，Java中没有这个概念，很多人把字段（Field）称为属性（attribute），不要把
  成员变量叫做属性。
2. property：表示状态，但是不是字段，是属性的操作方法（getter/setter）决定的，框架中
  使用的大多是属性。

七.this关键字

this主要存在于两个位置：
构造器中：表示当前创建的对象
方法中：哪一个对象调用this所在的方法，那么此时this就表示哪一个对象。
当一个对象创建之后，JVM会分配一个引用自身的应用this。

新建UserDemo.java

//用户信息
//用户信息
class User
{
	private int age;
	private String name;
	
	User(){
		System.out.println(this);//打印this
	}
	public int getAge(){
		return age;
	}

	public void setAge(int age){
		this.age = age;//表示成员变量
	}

	public void show(){
		System.out.println(this.age);//打印this.age
	}
}
class UserDemo
{
	public static void main(String[] args) 
	{
		User u = new User();
		System.out.println(u);//打印当前对象
		u.setAge(3);

		User u1 = new User();
		u1.setAge(6);
		
		u.show();
		u1.show();
	}
}

![image][this]

this的使用场景：
1. 解决成员变量和参数（局部变量）之间的二义性，必须使用；
2. 同类中中实例方法之间互调（此时可以省略）；
3. 将当前对象作为参数传递给另一个方法
4. 将当前对象的作为方法的返回值（链式方法编程）
5. 构造器重载的互调，this([参数])必须写在构造方法第一行
6. static不能和this一起使用
7. 当字节码被加载进JVM虚拟机，static成员已经存在了，但此时对象还没创建出来，没有对象，就没有this。

八.构造器和setter方法选用

创建对象并给对象设置初始值有两种方式：
1. 方式1：先通过无参构造器创建一个对象，再通过对象调用相应的setter方法。
2. 方式2：直接使用直接调用带参数的构造器，创建出来的对象，就有初始值。
通过构造器和通过setter方法都可以完成相同的功能。
1. 对象设置数据：
  1. setter注入（属性）
  2. 构造注入
2. 选择：
  1. 如果存在带参的构造器，方法2比较简洁。
  2. 如果在构造对象的时候要初始化多个数据，如果使用方式2，那么构造器得提供N个参数，不直观，
    此时方式1，简单明了。
  3. 圆对象，如何画圆，圆对象要根据半径来确定对象，就应用在构建圆的时候就要确定半径值。
  4. 有时候需要根据数据来构建对象，此时优先使用构造器方式。

九.判断点和圆的关系

判断圆个点的关系

新建PointDemo.java

//点和圆的关系
//点对象
class Point
{
	private double x;
	private double y;
	Point(double x,double y){
		this.x = x;
		this.y = y;
	}
	void setX(double x){
		this.x = x;
	}
	void setY(double y)
	{		
		this.y = y;
	}

	double getX(){
		return this.x;
	}
	double getY(){
		return this.y;
	}
	void showPoint(){
		System.out.println("x = " + this.x + ","+ "y = " + this.y);
	}
}
//圆对象
class Circle
{
	private double x;
	private double y;
	private double r;
	Circle(double x,double y,double r){
		this.x = x;
		this.y = y;
		this.r = r;
	}

	void setX(double x){
		this.x = x;
	}
	void setY(double y){
		this.y = y;
	}
	void setR(double r){
		this.r = r;
	}

	double getX(){
		return x;
	}
	double getY(){
		return y;
	}
	double getR(){
		return r;
	}
	void showCircle(){
		System.out.println("x = " + this.x + "," + "y = " + this.y + "," + "r = " + this.r);
	}
}
class PointDemo 
{
	//点到圆心的距离比较半径的长度
	static void compare(Point p,Circle c){
		double distante = (p.getX() - c.getX()) * (p.getX() - c.getX()) + (p.getY() - c.getY()) * (p.getY() - c.getY());
		if (distante < c.getR() * c.getR())
		{
			System.out.println("点在圆内");
		}else if (distante > c.getR() * c.getR())
		{
			System.out.println("点在圆外");
		}else{
			System.out.println("点在圆上");
		}
	}
	public static void main(String[] args) 
	{
		//设置点在圆内
		Point p = new Point(4.0,2.0);
		p.showPoint();
		Circle c = new Circle(0.0,0.0,5.0);		
		c.showCircle();
		compare(p,c);
		System.out.println("------------");

		//设置点在圆上
		p.setY(3.0);
		p.showPoint();
		c.showCircle();
		compare(p,c);
		System.out.println("------------");

		//设置点在圆外
		p.setY(8.0);
		p.showPoint();
		c.showCircle();
		compare(p,c);
	}
}

huang_kuh

发布了58 篇原创文章 · 获赞 0 · 访问量 739

私信关注