封装&构造,成员方法&this,static关键字

1封装

封装的概念:
	Java提供这样一种技术:
	将一个类的成员变量私有化,外界不能够直接方案,可以通过一些公共的方法(set/get...)间接的访问!

private关键字:
		private:私有的,外界不能访问的!只能在本类中访问
					(但是可以间接通过公共的成员方法来访问私有成员变量/成员方法)
		
		它可以修饰成员变量,也可以修饰成员方法

class Person{
	//公共的成员变量
	public int num = 100 ;
	//私有的成员变量
	private int num2 = 200 ;
	//提供一个公共的方法
	public void show(){
		System.out.println(num) ;
		System.out.println(num2) ;
	}
	//私有的成员方法
	private void method(){
		System.out.println("method...") ;
	}
	public void function(){
		method() ;
	}
}
//测试类
class PrivateDemo{
	public static void main(String[] args){
		//需求:访问Person类中的num和num2如何访问
		//创建Person类对象
		Person p = new Person() ;
		System.out.println(p.num) ;
		//System.out.println(p.num2) ;//num2 在 Person 中是 private 访问控制
		System.out.println("--------------------") ;
		p.show() ;
		//p.method() ;//method() 在 Person 中是 private 访问控制
		p.function() ; //通过公共的成员方法间接访问本类中私有成员方法
	}
}

如何解决非法数据呢?
			提供一个判断功能:
				年龄如果<0或者>180 ,提示"当前学生的年龄非法数据"
				否则,将当前局部变量赋值age(成员变量)	
			将功能定义学生类:作为它的成员方法!

	public void setAge(int a){//判断年龄
		if(a <0 || a>180){
			System.out.println("当前学生的年龄是一个非法数据!!") ;
		}else{
			age = a ; 
		}
	}

2.this关键字

this:代表当前类对象的地址值引用!	
				为了区分:局部变量隐藏成员变量: this.成员变量;

	public void setName(String name){ //高圆圆
		this.name = name ; //this.name = "高圆圆"
	}
	
	public void setAge(int age){//39
		this.age = age ;//this.age = 39
	}
	
	public void setGender(String gender){//"女"
		this.gender = gender ; //this.gender = "女"
	}	

3.构造方法

1).构造方法的特点及作用

	特点:
		1)方法名和类名相同
		2)没有具体的返回值类型
		3)连void都没有	
		权限修饰符 方法名和类名相同(){  //无参构造方法	
			}	
	作用:给对象的成员进行数据初始化的!

class Student{
	public Student(){
		System.out.println("这是学生类的无参构造方法...") ;
	}	
}
//测试类
class ConstructorDemo{
	public static void main(String[] args){
		//创建学生类对象
		Student s = new Student() ;  //先去访问学生类无参构造方法
		System.out.println(s) ; //Student@6d06d69c
	}
}

2)注意事项

	构造方法:
		构造方法是可以重载的:
			无参构造方法
			有参构造方法				
	注意事项:
			在写一个类的时候,没有提供无参构造方法,系统默认提供无参构造方法!
			如果开发者提供有参构造方法,系统不会提供无参构造方法了,所以永远给出无参构造方法!

class Student{
	String name ;//姓名
	int age ; //年龄
	//无参构造方法
	public Student(){
		System.out.println("Student的无参构造方法...") ;
	}
	//定义一个带一个参数的有参构造方法
	public Student(String name){
		System.out.println("Student带一个String类型的构造方法...") ;
	}
	public Student(int  age){
		System.out.println("Student带一个int类型的构造方法...") ;
	}
	public Student(String name,int age){
		System.out.println("Student的有参构造方法...") ;
	}
}
//测试类
class ConstructorDemo2{
	public static void main(String[] args){	
		//创建一个学生对象
		Student s = new Student() ;
		System.out.println(s) ;
		System.out.println("----------------------------") ;
		//在创建一个学生对象
		Student s2 = new Student("拳皇") ;
		System.out.println(s2) ;
		System.out.println("----------------------------") ;
		Student s3 = new Student("拳皇",39) ;
		System.out.println(s3) ;
	}
}

4.成员方法

分类:
		有具体返回值类型的方法
							带形参的
							不带形参的
		没有具体返回值类型的方法
							带形参的
							不带形参的

	public String show(int i){
		return "hello"+i ;
	}
	//2)不带参的
	public String method(){
		return "hello JavaSE!" ;
	}
	//没有具体返回值类型:使用void代替返回值类型
	//1)带参的
	public void function(String str){
		System.out.println(str) ;
		function2() ;
	}
	//2)不带参
	private void function2(){
		System.out.println("function2 Demo...") ;
	}

5.static关键字

1)static关键字的特点

		1)被static修饰的成员,随着类的加载而加载 (类就加载一次!)
		  javac xxx.java---->xxx.class  (字节码文件)
		  java xxx ---->运行---->加载类的时候,对象还没开始创建  
		2)优先于对象存在 
				对象的创建是在类加载的后面		
		3)有被共享,共用的意思
			这句话:告诉我们什么时候使用static修饰变量,方法,能够描述被共用,共享的时候		
		4)最重要的特点:
			被static修饰的变量以及方法可以被类名直接访问!(推荐类名直接访问)	
			这些被static修饰变量/方法,也可以通过对象名来访问(不推荐!)

//静态的成员变量
	public static int num = 10 ;  //被static修饰的变量---->类变量
	//非静态的
	public int num2 = 200 ;
	//成员方法(非静态的)
	public void method(){
		System.out.println("method Demo") ;
	}
	//静态的方法 (与类相关!)
	public static void function(){
		System.out.println("fucntion Demo") ;
	}

2)static关键字的注意事项

		1)static关键字中 没有this的关键字的	
		2)关于访问的问题:	
			非静态的成员方法,既可以访问静态的变量,也可以非静态的变量
						也可以访问静态的方法以及非静态的成员方法	
						静态的方法只能静态的变量/方法			

	//成员方法
	public void show(){
		System.out.println(num);
		System.out.println(num2) ;
	}
	//成员方法
	public void function(){
		method();
		show() ;
	}
	//静态的方法
	public static void method(){
		//访问num变量呢?
		//System.out.println(num) ; //无法从静态上下文中引用非静态 变量 num
		System.out.println(num2) ;
		System.out.println("method demo..") ;
		//show() ;//无法从静态上下文中引用非静态 方法 show()
	}