java封装

1通过无参构造与有参构造赋值

package cn.bdqn.demo01;

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);
	}

}

package cn.bdqn.demo01;

public class PenguinTest {

	public static void main(String[] args) {
		// 使用无参构造方法创建Penguin类的对象
		Penguin penguin1 = new Penguin();
		//给对象penguin1的属性赋值
		penguin1.name = "QQ";
		penguin1.health = 90;
		penguin1.love = 99;
		penguin1.printInfo();
		
		Penguin penguin2 = new Penguin();
		//给对象penguin1的属性赋值
		penguin2.name = "大壮";
		penguin2.health = -20;
		penguin2.love = -99;
		penguin2.printInfo();

	}

}

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

package cn.bdqn.demo02;

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 setName(String name){
		this.name=name;
	}
	
	public String getName(){
		return name;
	}
	
	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 int getHealth(){
		return health;
	}
	
	public void setLove(int love){
		//对传递过来的love值进行判断
		if(love<0||love>100){
			System.out.println("您输入的亲密度值有误，默认给亲密度赋值为80");
			this.love=80;
			return;
		}
		this.love=love;
	}
	
	public int getLove(){
		return love;
	}
	

	// 定义一个方法输出对象信息
	public void printInfo() {
		System.out.println("宠物信息：昵称：" + this.name + "，健康值：" + this.health
				+ "，亲密度：" + this.love);
	}
}

package cn.bdqn.demo02;


public class PenguinTest {

	public static void main(String[] args) {
		// 使用无参构造方法创建Penguin类的对象
		Penguin penguin1 = new Penguin();
		// 给对象penguin1的属性赋值,因为name属性使用private修饰了，所以不能同对象名.属性名直接给name属性赋值，只能是用其它方式给name属性赋值
//		penguin1.name = "QQ";
//		System.out.println(penguin1.name);
		
		penguin1.setName("QQ");
		String name =penguin1.getName();
		System.out.println(name);
		
		penguin1.setHealth(-90);
		System.out.println(penguin1.getHealth());
		
		penguin1.setLove(-99);
		System.out.println(penguin1.getLove());
	}

}

导包，如何使用不同包里面的同名类

//定义包
package cn.bdqn.demo03;

public class Test {

	public static void main(String[] args) {
		//创建Penguin类对象
		//如何使用不同包里面的同名类
		cn.bdqn.demo01.Penguin penguin1 = new cn.bdqn.demo01.Penguin();
		cn.bdqn.demo02.Penguin penguin2 = new cn.bdqn.demo02.Penguin();
		
		//java.lang包里面的类由系统自动导入，不需要写导包语句
		double num =Math.random();

	}

}

 * 一个Java文件中只能有一个public修饰的类，并且这个类名要与Java文件名保持一致
 * 一个Java文件中可以有多个默认修饰符修饰的类
 * 建议一个Java文件中只写一个类

package cn.bdqn.demo04;


public class Demo {

}

class Test{
	
}

class CeShi{
	
}
 

static可以用来修饰

        成员变量

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

         成员方法

                静态方法，可以直接通过类名访问

         代码块

                静态代码块，当Java虚拟机加载类时，就会执行该代码块

                

类的成员变量包括

        类变量（静态变量）

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

        实例变量

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

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

静态方法：可直接通过类名访问 静态方法中不能使用this和super 不能直接访问所属类的实例变量和实例方法 可直接访问类的静态变量和静态方法

实例方法：通过实例访问 可直接访问所属类的静态变量、静态方法、实例变量和实例方法

静态方法必须被实现