1.封装概念：

①将类的某些信息隐藏在类内部，不允许外部程序进行直接访问。

②通过该类提供的方法来实现对隐藏信息的操作和访问。

简单地说：隐藏对象的信息，留出访问的接口。

例子：钞票是ATM机的重要信息，我不能随意的去拿到里面的金钱，但是我可以通过银行卡，操作屏，取钞口等暴露出的接口获取金钱。

封装的特点：

1.只能通过规定的方法访问数据。

2.隐藏类的实例细节，方便修改和实现。

2. 封装的实现步骤：

①修改属性的可见性。设置为private私有化（只能在当前类内被访问，出了这个就不能被访问），通过这步实现信息的隐藏。

②设置开发接口：创建getter/setter方法（取值/赋值），设为public用于属性的读写。

③在getter/setter方法中加入属性控制语句。对属性值得合法性进行判断。（年龄需大于0等等）

3.代码实现：

第一步，修改属性为private

在测试类发现报错，可以证明类外不能直接访问private修饰的属性

cat类：

将代码修改为用private修饰，get set方法

package com.hoomsun.animal;

/**
 * 宠物猫类
 * 
 * @author dongwenjie
 *
 */
public class Cat {
	// 成员属性：昵称、年龄、体重、品种
	private String name;
	private int month;
	private double weight; 
	private String species;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getMonth() {
		return month;
	}

	public void setMonth(int month) {
		this.month = month;
	}

	public double getWeight() {
		return weight;
	}

	public void setWeight(double weight) {
		this.weight = weight;
	}

	public String getSpecies() {
		return species;
	}

	public void setSpecies(String species) {
		this.species = species;
	}

	public Cat() {
		System.out.println("我是无参构造方法");
	}

	public Cat(String name, int month, double weight, String species) {
		this();
		this.name=name;
		this.month =month;
		this.weight=weight;
		this.species=species;
	}

	// 成员方法：跑步、吃东西
	public void run() {
		String name;
		System.out.println("小猫快跑");
		System.out.println(this.name);
//		System.out.println(name);
	}

	public void eat() {
		System.out.println("小猫吃鱼");
	}
}

catTest类

package com.hoomsun.animal;

/**
 * 猫测试类
 * 
 * @author dongwenjie
 *
 */
public class CatTest {
	public static void main(String[] args) {
		// 对象猫实例化
		Cat one = new Cat();

		Cat two = new Cat();

		Cat three = new Cat("二笔呆", 16, 12.5, "英国短毛猫");
		
		// 测试方法
		one.eat(); // 小猫吃鱼
		one.run(); // 小猫快跑
		// 测试属性

		/*
		 * 对于一个类当中的成员属性而言，系统会默认给一个初始值的 字符串默认：null, double浮点数：0.0， int整型：0
		 */
		one.setName("小呆呆");
		one.setMonth(15);
		one.setWeight(8.6);
		one.setSpecies("狸花猫");

		two.setName("阿呆呆");
		two.setMonth(1);
		two.setWeight(2.6);
		two.setSpecies("花猫");
		System.out.println("名字：" + one.getName()); // 名字：小呆呆
		System.out.println("年龄：" + one.getMonth()); // 年龄：15
		System.out.println("体重：" + one.getWeight()); // 体重：8.6
		System.out.println("品种：" + one.getSpecies()); // 品种：狸花猫

		System.out.println("名字：" + two.getName()); // 名字：阿呆呆
		System.out.println("年龄：" + two.getMonth()); // 年龄：1
		System.out.println("体重：" + two.getWeight()); // 体重：2.6
		System.out.println("品种：" + two.getSpecies()); // 品种：花猫
		
		System.out.println("名字：" + three.getName()); // 名字：二笔呆
		System.out.println("年龄：" + three.getMonth()); // 年龄：16
		System.out.println("体重：" + three.getWeight()); // 体重：12.5
		System.out.println("品种：" + three.getSpecies()); // 品种：英国短毛猫

		System.out.println(one); // com.hoomsun.animal.Cat@7852e922
		System.out.println(two); // com.hoomsun.animal.Cat@4e25154f
		System.out.println(one == two); // false
		two = one;
		System.out.println(one);
		System.out.println(two);
		two = one;

	}
}

4.只有getxxx方法的属性是只读属性，只有setxxx方法的属性是只写属性。

5.通过异常处理的方式可以优化程序。

6.通过带参构造函数中调用set方法赋值是比较保险的。可以设置一些条件，比如年龄不能小于0等。

4.在Java当中如何进行不同类文件的管理呢？

通过包来进行文件的管理，解决同名文件冲突问题的。一个包里面不能建同名的类。（域名倒叙+模块+功能）

包引用必须放在类文件第一行。

建议每个包内存储信息功能单一

5.如何实现跨包的类调用，有几种调用形式？

全局引入和按需引入。

import com.hoomsun.animal.*;
import com.hoomsun.animal.Cat;

建议采取”import 包名.类名“的方式加载，提高效率。

加载类的顺序跟import导入语句的位置无关。

作用：①管理java文件 ②解决同名文件冲突。

定义包：package包名；例：package com.immoc.animal;

注意：必须放在java源文件中的第一行

一个java源文件中只能有一个package语句

包名全部英文小写

命名方式：域名倒叙+模块+功能。

6.static关键字。（静态信息）

首先猫类里面定义一个price属性

测试猫类里面去做赋值

给price加上static修饰符,会发现price变成了斜体。

然后测试类中报了一条警告，而且价格全变成了4000.

static:静态 静态成员  类成员  用static修饰的 无论这个类实例化出了多少对象，都会公用同一块存储空间。

对于普通的成员而言，当这个对象实例产生的时候，它的相关成员会产生。而对象销毁的时候，这些成员会进行自然释放。

静态成员则不然，当类第一次加载的时候就会产生，一直到这个类不再有任何对象被使用，也就是彻底销毁的时候，静态成员才会被彻底的释放。

特点总结：

①类对象共享 ②类加载时产生，销毁时释放，声明周期长。③既可以通过对象名访问，也可以通过类名访问。

static+属性===>静态属性/类属性

static+方法===>静态方法/类方法（也可以通过类名.方法名调用）

static不能加载类名前面否则会报错，类前面只能加 public abstract final三个关键字。

可以有静态属性 静态方法 不能有静态类

static也不能用于方法内的局部变量。

在成员方法当中，是可以直接访问类的静态成员的。反之，

在静态成员方法中不能访问非静态成员，如下报错了：(如果非要访问，需要先实例化一个对象，在调用)

 静态方法中也不能使用this，this代表实例，和static冲突。

7.代码块的概念

出现大括号对，就叫做代码块。在方法中定义时，就是普通代码块。

在类中定义构造代码块，会优先于构造方法执行，可以有多个构造代码块，按顺序执行。

加了static关键字就是静态代码块，静态代码块优先于构造代码块。

总结：

封装：①通过该类提供的方法来实现对隐藏信息的操作和访问。（隐藏对象的信息，留出访问接口）

封装的特点：①只能通过规定的方法访问数据。②隐藏类的实例细节，方便修改和实现。（我们只需要如何使用，并不需要深究它的内部实现构造）

封装的步骤：

包：作用：1.管理java文件。2。解决同名文件冲突。

定义包：package 包名;

注意：

导入包：

static属性：