【java】包package、引用import、类的封装和隐藏、四种访问权限修饰符、类的构造方法、this关键字

包package

包(package) 是Java 提供的一种区别类的命名空间的机制，是类的组织方式(相当于Windows系统中的文件夹和子文件)，是一组相关类和接口的集合，它提供了访问权限和命名的管理机制。

包和文件夹一样可以有多级，也就是包下可以有包和文件，多级的包可以使用“ . ”分隔，例如com包下的cn包下的test包，写法就是com.cn.test

import

import语句给出了要使用哪个包下的哪个类。

例如：
引入com.sdau包中的ABC类：

import com.sdau.ABC;

引入该包下的全部类：

import com.sdau.*;

类的封装

把属性声明设置为私有的，用private关键字，通过编写public类型的setXxx()和getXxx()方法来设置属性。

例如：

public class Main {
    public static void main(String args[]) {
    	Person p = new Person();
    	p.setAge(12);
    	p.printAge();
    }
}

public class Person {
	private int age;

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	
	public void printAge() {
		System.out.println("年龄是：" + age);
	}
}

其输出结果为：

四种访问权限修饰符

【例】有A、B、C三个类，A、B两类属于同一包，A、C属于两个不同的包。在类A中，给出不同访问限制的属性、方法，在类B以及类C中，定义类A的一个对象ca，利用该对象访问有关的属性和方法，有允许的，又不允许的。

package teat1;
public class A {
	private int a1;
	private int sum1(int m,int n) {
		return m+n;
	}
	/**
	  * 1、属性a1、方法sum1()是私有的，只能在本类内部可直接访问
	  * 2、在其他任何类中都不能被访问
	  */
	public int a2;
	public int sum2(int m,int n) {
		return m+n;
	}
	/**
	  * 1、属性a2、方法sum2()是公有的，在本类中可直接访问
	  * 2、在其他类中，可通过对象访问该属性
	  */
	int a3;
	int sum3(int m,int n) {
		return m+n;
	}
	/**
	  * 1、属性a3、方法sum3()是友好的，在本类中可直接访问
	  * 2、在同包的其他类中可以通过其他类访问
	  * 3、在非同包的其他类中，不可以访问
	  */
	protected int a4;
	protected int sum4(int m,int n) {
		return m+n;
	}
	/**
	  * 1、属性a4、方法sum4()是保护的，在本类中可直接访问
	  * 2、不在同包下的非子类中不允许访问
	  * 3、在同包下的非子类中允许访问
	  */
	public A(int a,int b,int c,int d) {//类A的构造方法
		this.a1 = a;
		this.a2 = b;
		this.a3 = c;
		this.a4 = d;
	}
}

package teat1;
public class B {
	public static void main(String[] args) {
		A ca = new A(10, 20, 30, 40);
		ca.a1 = 18;//错误，访问不到私有的a1
		ca.a2 = 18;//正确
		ca.a3 = 18;//正确
		ca.a4 = 18;//正确
	}
}

package test;
import teat1.A;
public class C {
	public static void main(String[] args) {
		A ca = new A(10, 20, 30, 40);
		ca.a1 = 18;//错误，访问不到私有的a1
		ca.a2 = 18;//正确
		ca.a3 = 18;//错误
		ca.a4 = 18;//错误
	}
}

类的构造方法

new对象的根本原理就是通过类的构造方法。

Person p = new Person();

new Person()对象调用的是类里无参的构造函数：public Person(){}
默认的构造方法前面的访问权限修饰符与定义类前的修饰符一致

例题：

package teat1;
public class Main {
	public static void main(String[] args) {
		Point p = new Point(1,2,3);
		p.setPoint(4, 5, 6);
	}
}

package teat1;
public class Point {
	int x;
	int y;
	int z;
	public Point(int m,int n,int k){
		x = m;
		y = n;
		z = k;
	}
	public void setPoint(int m,int n,int k) {
		x = m;
		y = n;
		z = k;
	}
}

构造方法的重载

为了方便调用方可以灵活的创建出不同需要的对象

关键字this

• 在java中，this关键字比较难理解，它的作用和其词义很接近。
  它在方法内部使用，即这个方法所属对象的引用;
  它在构造器内部使用，表示该构造器正在初始化的对象。
• this表示当前对象，可以调用类的属性、方法和构造器
• 什么时候使用this关键字呢?
  当在方法内需要用到调用该方法的对象时，就用this。

public class Person {
	int age;
	String name;
	
	public Person(int age,String name) {
		this.age = age;
		this.name = name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void setName1(String name) {
		this.setName(name);
	}
	public void showInfo() {
		System.out.println("姓名：" + this.name);
		System.out.println("年龄：" + this.age);
	}
}

注意：
1、当形参与成员变量重名时，如果在方法内部需要使用成员变量，必须添加this来表明该变量时类成员
2、在任意方法内，如果使用当前类的成员变量或成员方法可以在其前面添加this，增强程序的阅读性
3、this可以调用构造方法

public class Person {
	int age;
	String name;
	public Person(){}
	public Person(int age) {
		this.age = age;
	}
	public Person(String name) {
		this();           //等同于调用public Person()
		this.name = name;
	}
	public Person(int age,String name) {
		this(1);          //等同于调用public Person(int age)
		this.age = age;
		this.name = name;
	}
}

4、使用this()必须放在构造器的首行!
5、使用this调用本类中其他的构造器，保证至少有一个构造器是不用this的。