Java封装

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

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

隐藏对象的信息

留出访问的接口

实现步骤

1.修改属性的可见性（设为private，限定只能在当前类内访问）

private String name;

2.创建getter/setter方法（设为public，用于属性的读写）

3.在getter/setter方法中加入属性控制语句（对属性值的合法性进行判断）

        //创建get/set方法
	//在get/set方法中添加对属性的限定
	public void setName(String name) {
		this.name=name;
	}
	public String getName() {
		return "我是："+this.name;
	}

                one.setName("嘟嘟");
		System.out.println(one.getName());

快速创建getter/setter方法：空白区域-右键Source-Generate Getters and Setters

只有getXXX方法的属性是只读属性

只有setXXX方法的属性是只写属性

加入属性控制语句：

        public int getMonth() {
		return month;
	}
	public void setMonth(int month) {
		if(month<=0) {
			System.out.println("年龄不能为负数");
		}else {
			this.month = month;
		}
	}

                one.setMonth(3);
		if(one.getMonth()==0) {
			return;
		}
		System.out.println(one.getMonth());

利用带参构造方法对成员属性进行赋值时，同样建议采用get/set方法进行属性控制

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

Cat one = new Cat(10);
//或者改为
Cat one = new Cat(-10);

public class Message {
	public Message(MessageYonghu a,MessageYonghu b) {
		if((a.getName()==b.getName())&(a.getCode()==b.getCode())){
			System.out.println("================");
			System.out.print("完全一致");
		}else {
			System.out.println("================");
			System.out.print("用户名或密码不一致");
		}
	}
}

public class MessageYonghu {
	private String name;
	private int code;
	public MessageYonghu(String a,int b){
		this.code=b;
		this.name=a;
	}
	public String getName() {
	return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getCode() {
		return code;
	}
	public void setCode(int code) {
		this.code = code;
	}
}

public class MessageTest {
	public static void main(String[] args) {
		MessageYonghu c = new MessageYonghu("Lucy", 13456);
		MessageYonghu d = new MessageYonghu("Mike", 123456);
		System.out.println("用户名：" + c.getName());
		System.out.println("密码：" + c.getCode());
		System.out.println("用户名：" + d.getName());
		System.out.println("密码：" + d.getCode());
		Message s = new Message(c, d);
	}
}

使用包进行类管理

Java中一个包里不能存在同名类

包的命名(全部英文小写)：域名倒序+模块+功能

package com.imooc.animal;//定义包

必须放在Java源文件中的第一行

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

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

XXX cannot be resolved to a type无法解析的一种类型（俗称：找不到）

如何跨包调用？

import com.imooc.animal.*;//加载com.imooc.animal下所有类

import com.imooc.animal.Cat;//加载com.imooc.animal下指定的Cat类

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

//直接加载com.imooc.animal.CatTest

com.imooc.animal.CatTest tex=new com.imooc.animal.CatTest();

//会报错,程序无法分辨两个不同包下的Cat类
import com.imooc.animal.Cat;
import com.imooc.mechane.Cat;

加载类的顺序跟import导入语句的位置无关，先去找能够直接解析的类

import com.imooc.animal.Cat;//只执行它的Cat类，因为以类名导入优先级最高
import com.imooc.mechane.*;

com.imooc.mechane.Cat cat=new com.imooc.mechane.Cat();//强制执行包mechane下的Cat类

import 包名.*;只能访问指定包名下的类，无法访问子包下的类

static关键字

//static：静态 静态成员、类成员 无论在该类中实例化多少个对象，对于静态成员price，他们都会共用同一块存储空间
//类加载时产生，彻底销毁时释放，生命周期长
public static int price;

                //类外静态成员访问方式
		//类.成员
		Cat.price=30;
		//对象.成员
		cat.price=1000;

通过该类实例化的所有对象都共享类中静态资源，任一对象中信息的修订都将影响所有对象。

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

static+方法=静态方法/类方法

static不能修饰类以及方法内的局部变量

在成员方法中，可以直接访问类中静态成员（属性和方法）

静态方法中不能直接访问同一个类的非静态成员和方法，只能直接调用同一个类的静态成员和方法

只能通过对象实例化后，对象.成员方法的方式访问非静态成员和方法

静态方法中不能使用this

public static void eat() {
                //类内非静态成员访问方式：生成对象，通过对象访问
		Cat temp=new Cat();
		temp.run();
                temp.name="dudu";
		this.name="dudu";//报错
		name="dudu";//报错
		price=1300;
	}

不允许在方法内定义静态变量，如static int test=10;错误

{
}//普通代码块，定义在方法内部，顺序执行代码

{
}//构造代码块（创建对象时调用，优先于构造方法执行）定义在类内部，
//可以给普通成员和静态成员赋值
//与构造方法的区别在于，构造方法是在new执行时有选择性的调用带参或者无参构造，而构造代码块则是，在每个对象实例化时都一定会执行

static{
}//静态代码块（类加载时调用，优先于构造代码块执行）定义在类内部，
//只能给静态成员赋值，除非对象实例化

 无论产生多少类实例，静态代码块只执行一次，仅希望执行一次的代码可以放在静态代码块中

执行优先级：静态代码块>构造代码块>构造方法

不能在静态代码块声明静态成员，可以声明非静态成员

静态代码块中生命的成员，在外部无法进行访问

方法内定义的局部变量，作用范围为：自定义位置起，至方法结束。在此期间，不允许方法中普通代码块内存在局部变量的声明