封装

public class Penguin {
	//定义属性
	public String name;
	public int health;
	public int love;
	public Penguin() {
	}
	public Penguin(String name, int health, int love) {
		this.name = name;
		this.health = health;
		this.love = love;
	}
	//定义一个方法输出对象信息
	public void printInfo(){
		System.out.println("宠物信息：昵称"+this.name+"，健康值"+this.health+"，亲密度"+this.love);
	}
}
 
 
public static void main(String[] args) {
		//使用无参构造方法传概念Penguin类的对象
		Penguin penguin1 = new Penguin();
		//给对象penguin1的属性赋值
		penguin1.name="QQ";
		penguin1.health=12;
		penguin1.love=-3;
		penguin1.printInfo();
		Penguin penguin2 = new Penguin();
		//给对象penguin2的属性赋值
		penguin2.name="OO";
		penguin2.health=-1000;
		penguin2.love=-1000;
		penguin2.printInfo();
	}

创建的对象可以直接通过对象名，属性名去赋值，从而造成了在赋值的时候能够轻易的赋予一个不合理的值。 能不能使用一种方式，让对象不能直接去通过对象名.属性名赋值，而是间接的去给属性赋值，可以使用封装来实现这一个需求

封装的概念

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问

封装的原则

将不需要对外提供的内容都隐藏起来
把属性隐藏，提供公共方法对其访问。

封装有：
    属性的封装、方法的封装、类的封装、组件的封装、模块化的封装、系统级封装

如何实现封装

（1）.修改属性可见性:设为private，防止错误的修改
（2）.创建公有的getter/setter方法:用于属性的读写
（3）.在getter/setter方法中加入属性控制语句:对属性值的合法性进行判断

public class Penguin {
	// 定义属性
	private String name;
	private int health;
	private int love;
 
	public Penguin() {
	}
 
	public Penguin(String name, int health, int love) {
		this.name = name;
		this.health = health;
		this.love = love;
	}
 
	// 定义一个方法输出对象信息
	public void printInfo() {
		//这里可以直接使用对象.属性名，因为这里的this.name和前面使用private修饰的属性是在同一个类中的
		System.out.println("宠物信息：昵称" + this.name + "，健康值" + this.health
				+ "，亲密度" + this.love);
	}
	
	public void setName(String name) {
		this.name = name;
	}
 
	public String getName() {
		return name;
	}
 
	public int getHealth() {
		return health;
	}
 
	public void setHealth(int health) {
		//调用此方法给对象health赋值，在赋值前对传过来的health进行判断
		if(health<0||health>100){
			System.out.println("输入有误，默认健康值60");
			this.health=60;
			return;//这里的return作用是结束方法后续代码的执行
		}
		this.health = health;
	}
	public void setLove(int love) {
		//对传递过来的love值进行判断
		if(love<0||love>100){
			System.out.println("输入有误，默认亲密度80");
			this.love=80;
			return;//这里的return作用是结束方法后续代码的执行
		}
		this.love = love;
	}
 
	public int getLove() {
		return love;
	}
}

public static void main(String[] args) {
		// TODO Auto-generated method stub
		Penguin penguin1 = new Penguin();
		// 给对象penguin1的属性赋值,因为name属性使用private修饰了，所以不能通过对象名.属性名直接给那么属性赋值
		// 只能通过其它方法给其间接赋值
		/*
		 * penguin1.name="QQ"; 
		 * penguin1.health=12; 
		 * penguin1.love=-3;
		 * penguin1.printInfo();
		 */
		penguin1.setName("QQ");
		penguin1.getName();
		penguin1.setHealth(-60);
		penguin1.setLove(-20);
		penguin1.getHealth();
		penguin1.getLove();
		penguin1.printInfo();
	}

封装的好处

便于使用者正确使用系统，防止错误修改属性
有助于系统之间的松耦合，提高系统独立性
提高软件的可重用性
降低了构建大型系统的风险

封装的缺点

会影响执行效率

封装性总结

如果属性没有封装，那么在本类之外创建对象后，可以直接访问属性private关键字：访问权限修饰符;private表示私有的，私有的属性或方法只能在本类中访问共有的属性和方法可以被类外部的其他类访问。想要在类外部访问私有属性，我们需要提供拥有的方法来间接访问通常在一个类中属性都私有化，并对外提供getter and setter方法

包

1.为什么需要包

文档分门别类，易于查找和管理
使用目录解决文件同名冲突问题

2.包的作用

允许类组成较小的单元（类似文件夹），易于找到和使用相应的文件
防止命名冲突区分名字相同的类
有助于实施访问权限控制

3.如何创建包

package cn.jbit.inherit;   //声明包
        作为Java源代码第一条语句 
        用package声明包，以分号结尾

4.包命名规范

包名由小写字母组成，不能以圆点开头或结尾     package mypackage;
包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名 package net.javagroup.mypackage;包名后续部分依不同机构内部的规范不同而不同   package net.javagroup.research.powerproject;

5.用MyEclipse创建包

JDK提供基本包
        java.lang：虚拟机自动引入
        java.util：提供一些实用类
        java.io:输入、输出
使用MyEclipse创建包的两种方法
        分别创建包和类
        创建类的过程中创建类所在的包

6.如何导入包

为了使用不在同一包中的类，需要在Java程序中使用import关键字导入这个类
        import   包名. 类名；
        import java.util.*;      //导入java.util包中所有类
        import cn.jtest.classandobject.School;    //导入指定包中指定类
1. 系统包：java.util
2. 自定义包：cn.jtest.classandobject
*： 指包中的所有类
School ：指包中的School类

7.使用包的注意事项

一个类同时引用了两个来自不同包的同名类
        必须通过完整类名来区分
每个包都是独立的，顶层包不会包含子包的类
package和import的顺序是固定的
        package必须位于第一行（忽略注释行）
        只允许有一个package语句
        其次是import
        接着是类的声明

访问权限控制

类的访问控制
    public修饰符：公有访问级别
    默认修饰符：包级私有访问级别

类成员的访问控制

  
 

Static修饰符

static可以用来修饰

• 成员变量 静态变量，可以直接通过类名访问           

 类的成员变量包括

        类变量（静态变量）

                被static修饰的变量
                在内存中只有一个拷贝
                类内部，可在任何方法内直接访问静态变量
                其他类中，可以直接通过类名访问

        实例变量
                没有被static修饰的变量
                每创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响

• 成员方法  静态方法，可以直接通过类名访问
• 代码块  静态代码块，当Java虚拟机加载类时，就会执行该代码块

JVM加载类时，加载静态代码块

如果有多个静态块，按顺序加载
每个静态代码块只会被执行一次

public class StaticTest {
	//静态代码块
	//静态变量
	static int num=100;
    static{
           num+=100;
          System.out.println(num);//num=200
    }
    static{
           num+=100;
          System.out.println(num); 
   }
    
    public static void main(String[] args) {
    	//创建对象,java虚拟机会对类进行编译、运行、会将代码块一起执行，按照从上往下的顺序执行一次所有的代码块
		StaticTest st = new StaticTest();
	}
}

static变量的作用

（1）能被类的所有实例共享，可作为实例之间进行交流的共享数据
（2）如果类的所有实例都包含一个相同的常量属性，可把这个属性定义为静态常量类型，从而节省内存空间