构造方法,Static关键字,封装

构造方法

作用：对象的初始化

无参构造方法

语法：

实例：

//Dog1类文件
public class Dog1 {
	  //属性
		String name="小白";
		String strain="土狗" ;
		static int health=100;
		int love=50;
		//无参构造方法:对象的初始化
		public Dog1(){
			 this.name="小黄";
			 System.out.println("无参构造");
		}
		//方法
		public void show(){
			System.out.println("名字："+this.name+"\t品种："+this.strain+"\t健康值："+this.health+"\t亲密度："+this.love);
		}
}

//Dog1测试文件

public class Dog1Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//创建对象
				Dog1 dog = new Dog1();
				dog.name="小黑";
				dog.strain="拉布拉多";
				dog.health=100;
				dog.show();
				
	}
}

结果为：

在无参构造方法中，赋值了name为小黄，但是在测试文件中的对象又对name赋值了小黑。
注：
类的加载顺序：静态代码块>构造器>成员变量赋值
声明变量值的优先级：创建对象后赋值>构造器赋值>成员变量赋值

带参构造方法

语法：

访问修饰符  构造方法（参数列表）{
   //初始化代码；
}

实例：
//Dog1类文件

public class Dog1 {
	  //属性
		//static：静态         final：常量：无法改变
		String name="小白";
		String strain="土狗" ;
		static int health=90;
		final static int love=50;
		//带参构造
		public Dog1(String name){
			this.name=name;
			System.out.println("带参构造");
		}
	public void show(){
				System.out.println("名字："+this.name+"\t品种:"+this.strain+"\t健康值:"+this.health+"\t亲密度:"+this.love);
			}		
	}

//Dog1类测试文件

public class Dog1Test {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//创建对象
				Dog1 dog = new Dog1("小黑");
				dog.strain="拉布拉多";
				Dog1.health=100;        
				 dog.show();		
	}
}

结果为：

Static（静态）关键字

使用static定义变量，可以直接通过类名访问变量
使用static定义属性：
有上面带参构造的代码可知，static定义了health在测试文件中就可以用类名直接调用。
如：Dog1.health=100;
final表示固态,就是不可改变。如love就改不了30.

Static用来修饰方法：

//dog文件源代码

public class Dog {
  //属性
	//static：静态         final：常量：无法改变
	static String name="小白";
	static String strain="土狗" ;
	static int health=100;
	final static int love=50;
public  static void show(){
			System.out.println("名字："+name+"\t品种:"+strain+"\t健康值:"+health+"\t亲密度:"+love);
		}
		
}

//Dog测试文件的源代码

public class DogTest {

	public static void main(String[] args) {
		
    //创建对象
		Dog dog = new Dog();
		dog.name="小黑";
		dog.show();
  }
}

结果为：

注：

1. 在static的方法中必须使用静态变量；
2. 在静态方法中想使用其他类的非静态方法，需要创建对象，使用对象名调用；如dog.name=“小黑”；
3. 在静态方法中使用其他静态方法，如果是同一个类文件，直接调用，如果是不同类文件，使用类名调用

static静态代码块

静态代码块：随着类的加载而加载，优先于对象创建

	static {
		System.out.println("静态代码块");
	}

如上就是一个静态代码块；

static修饰与非static修饰的区别

封装

为什么使用封装：
将类的某些信息隐藏在类内部
以防止对象属性被任意访问，不合理的赋值

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

封装的步骤：

1. 修改属性的可见性，设为private
2. 创建共有的getter/setter方法,用于属性的读写
3. 在getter/setter方法中加入属性控制语句，对属性值的合法性进行判断
   实例：
   //Person文件中的源文件

//封装
import sun.management.resources.agent;
public class Person {
private String name;
private  int age;
 
   //age出口
   public int getAge(){
	   return age;
   }
   //age入口
   public void setAge(int age){
	   if (age>0&&age<100) {
		this.age=age;
	}else {
		this.age=50;
		System.out.println("请输入合法值，已改为合法值为50");
	}
   }
}

//person的测试文件

public class persontest {
	public static void main(String[] args) {
		// 创建对象
		//静态的不能直接访问只能用getter和setter方法
		Person per=new Person();
		per.setAge(60);
		System.out.println("年龄为："+per.getAge());
	}
}

结果为：

若测试文件最后两行为：

per.setAge(120);
		System.out.println("年龄为："+per.getAge());

结果就为：

从上图可知age被封装了在测试文件中不能使用对象修改，只能使用getter和setter方法调用。