Java学习笔记五（封装和几个关键字的使用）

面向对象的特征一：封装性

问题的引入： 当我们创建一个类的时候，我们可以通过实例化类来对类中的属性进行赋值操作。这时，赋值操作只受到属性的数据类型和存储范围的限制，没有其他的限制条件。但在实际问题中，我们可能还存在一些其他的限制条件，但是这些限制条件并不能在属性声明时体现，我们只能通过方法进行限制条件的添加，同时要防止用户再通过对象 . 属性的方法在对属性进行赋值，则需要把属性声明为私有的（private）。此时针对属性就体现了封装性。

封装性的体现： 我们将类的属性私有化（private），然后提供公共的（public）方法设置（set）和获取（get）属性的值。
注意：除了上面提到的属性的私有化，封装性还体现在不对外暴露的私有方法以及单例模式。

权限修饰符：Java规定的四种权限修饰符从小到大排列依次是private、缺省、protected、public。
这四种权限修饰符可以修饰类及类的内部成员；具体的说，可以修饰类中的：属性、方法、构造器、内部类；修饰类时只能使用public和缺省两种修饰符。
四种权限修饰符的课件范围：private只在类内可见，缺省可以在同一个包内的类间可见，protected可在不同包的子类中可见，public在不同包之间可见；

总结封装性：Java提供了四种权限修饰符来修饰类及类的内部成员，体现了类及类的内部成员在被调用时对外可见性的大小。
例子如下：

public class MyAnimalTest{
	public static void main(String[] args) {
		Animal1 ani = new Animal1();
		System.out.println(ani.getLeg());
		ani.setLeg(4);
		System.out.println(ani.getLeg());
		ani.setLeg(5);
		System.out.println(ani.getLeg());
	}
}
class Animal1{
	String name;
	private int age;
	private int leg;
	
	public void setLeg(int l) {
		if(l > 0 && l%2==0) {
			this.leg = l;
			
		}else {
			System.out.println("Error");
		}
	}
	public int getLeg() {
		return leg;
	}
}

类的内部成员之构造器（constructor）

构造器的作用：
1、创建对象
2、初始化对象的信息

构造器的结构：权限修饰符 类名（形参列表）；
几点注意事项：
1、如果类中没有提供构造器，则系统会默认提供一个空参的构造器；
2、一旦类中提供了构造器则系统就不会再提供空参的构造器；
3、同一个类中不同形参列表的构造器之间会构成重载；
4、每个类中至少会有一个构造器；

this关键字可以理解成创建或拟创建的对象。

public class MypersonTest {
	public static void main(String[] args) {
		
		Person1 p = new Person1();
		Person1 p1 = new Person1("shenshuo",24);
		System.out.println(p.getName()+","+p1.getName());
		p.setName("花花");
		System.out.println(p.getName()+","+p1.getName());
	}

}
class Person1{
	private String name;
	private int age;
	
	public Person1() {
		
	}
	
	public Person1(String name,int age) {
		this(); // 调用前面的构造器
		this.name = name;
		this.age = age;
	}
	
	
	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 void eat() {
		System.out.println("人吃饭");
	}
	public void study() {
		System.out.println("人可以学习");
	}
	
	
}

JavaBean是一种Java语言写成的课重用组件

所谓的JavaBean是符合以下标准的Java类：
1、一个公共的类（即用public修饰的类）
2、有一个无参的公共的构造器（即有public修饰的无参构造器）
3、有属性，且提供了属性的get、set方法

public class Customer {//公共的类
	
	private int id;
	private String name;//属性
	
	public Customer(){//公共的无参构造器
		
	}
	
	public void setId(int i){
		id = i;
	}
	public int getId(){//对应属性的get、set方法
		return id;
	}
	public void setName(String n){
		name = n;
	}
	public String getName(){
		return name;
	}
	
}

属性赋值的先后顺序：

依次为：
①默认初始化
②显式初始化
③构造器初始化
④通过对象。属性、对象。方法的方式赋值
①>②>③>④其中大于号是早于的意思。

三个关键字this、package和import：

this关键字的使用：
this关键字可以用来修饰：属性、方法、构造器；

this修饰属性和方法理解成当前对象，this修饰构造器理解成正在创建的当前对象。

在类的方法中：可以通过this.属性、this.方法的方式来调用当前对象的属性和方法，但一般this省略不写。特殊情况下，如果方法的形参名和类中的属性名相同时，则需要显示的使用this来说明此变量是属性而非形参。
在构造器中：可以使用this.属性、this.方法的方式来调用正在创建的当前对象中的属性和方法，但通常this省略不写，特殊情况下，如果构造器的形参名和类中的属性名相同时，则需要显示的使用this来说明此变量是属性而非形参。

this调用构造器：可以通过this（形参列表）的方式来调用本类中其他指定的构造器。
几点注意：
1、this（形参列表）只能放在构造器的首行，而且不能通过这种方式来调用它本身。
2、每个构造器中最多只能声明一个this（形参列表）来调用其他的构造器。
3、如果本类中有n个构造器，则最多只能有n-1个构造器使用了this（形参列表）来调用其他的构造器；

class Person{
	
	private String name;
	private int age;
	
	
	public Person(){
		
//		this.eat();
		String info = "Person初始化时，需要考虑如下的1,2,3,4...(共40行代码)";
		System.out.println(info);
	}
	
	public Person(String name){
		this();
		this.name = name;
		
	}
	
	public Person(int age){
		this();
		this.age = age;
		
	}
	
	public Person(String name,int age){
		this(age);
		this.name = name;
		//this.age = age;
		//Person初始化时，需要考虑如下的1,2,3,4...(共40行代码)
	}
	
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return this.name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public int getAge(){
		return this.age;
	}
	
	public void eat(){
		System.out.println("人吃饭");
		this.study();
	}
	public void study(){
		System.out.println("人学习");
	}
	
}

package关键字的使用：
为了更好的实现项目中类的管理，提出了包的概念；
使用package声明类或接口所属的包，声明在源文件的首行；
包也属于标识符，要遵循标识符的命名规则，包名都使用小写字母，还要做到见名知意；
其中，没 . 一次，代表了一层文件目录
注意：同一个包下不能有同名的类或接口，不同的包下可以有同名的类或接口。

import关键字的使用：（导入）
在源文件中使用import结构来导入指定保重的类和接口；
import一般声明在package和类的声明之间；
几点注意事项：
1、如果是本包下的或者是java.lang包下的类和接口，则不需要使用import导入；
2、如果有多个包中的结构需要导入，并列写出即可；
3、如果有两个不同包中的同名类，则在使用时至少要有一个类需要以全类名的方式显示。
4、可以使用“xxx.*”的方式导入xxx包下的所有结构。但是如果时该包下子包中的结构则还需要显示的导入子包。
import static用于导入类或接口中的静态结构（属性和方法）；
例如：

package com.atguigu.java2;

import java.lang.reflect.Field;