Java之面向对象之封装

将数据和方法包装进类中，加上具体实现的隐藏（访问修饰符），共同被称作封装，其结果是一个同时带有特征和行为的数据类型。
定义类，定义其属性，方法的过程称为封装类
封装类demo：

class Student{//相当于c的结构体；定义类
	int age;//定义属性
	String name;//java中没有指针字符串
	double score;
	
	void myPinrtf(){//定义方法
 //不用传参，可以直接调用上面的变量，因为面向对象
		System.out.println("age="+age +" name=" +name +" score=" +score);
	}
}

使用类的demo：

class Student{//相当于c的结构体
	int age;
	String name;//java中没有指针字符串
	double score;
	
	void myPinrtf(){//不用传参，可以直接调用上面的变量，因为面向对象
		System.out.println("age="+age +" name=" +name +" score=" +score);
	}
}


public class Demo1 {
	public static void main(String[] args) {
	
			Student stu = new Student();//实例化一个对象，这样才能调用这个类，相当于C结构体申请内存空间
			//类不能直接使用，不能直接访问变量，需要先实例化，申请一个空间
			stu.age = 21;
			stu.name = "zhaohaiping";//可以直接赋值字符串
			stu.score = 99.9;
			stu.myPinrtf();
	}
}

1.封装之访问修饰符

封装的概念：
public：该类或者非该类可以访问
private：只有该类可以访问
protected：该类及其子类的成员可以访问，用一个包中的类也可以访问
默认：同一个包中的类可以访问

属性封装的实现：
修改属性的可见性来限制对属性的访问
为每个属性创建一对赋值方法（setter）和取值（getter）方法，用于公开对这些属性的访问接口在setter和getter方法中，根据需要加入对属性操作的限制

class Student{//相当于c的结构体
    	int age;
    	String name;//java中没有指针字符串
    	double score;
    	private int sex;//只能在该类调用该变量
    	
    	public void setSex(int sex1){
    		sex = sex1;
    	}
	
	public int getSex(){
		return sex;
	}
	
	void myPinrtf(){//不用传参，可以直接调用上面的变量，因为面向对象
		System.out.println("age="+age +" name=" +name +" score=" +score);
	}
}


public class Demo1 {
	public static void main(String[] args) {
	
			Student stu = new Student();//实例化一个对象，这样才能调用这个类，相当于C结构体申请内存空间
			//类不能直接使用，不能直接访问变量，需要先实例化，申请一个空间
			stu.age = 21;
			stu.name = "zhaohaiping";//可以直接赋值字符串
			stu.score = 99.9;
			stu.myPinrtf();
			stu.setSex(1);//通过setSex接口间接调用private型的变量
			System.out.println("sex= "+stu.getSex());//和C一样，可以直接调用函数来打印函数的返回值
	}
}

方法封装的目的：
隐藏方法实现细节（方法体），向外部提供公开接口（方法头），以供安全调用简化调用，方便维护。根据需要可以私有化方法，以供内部使用–帮助方法

2.UML类图

UML：又称统一建模语言或标准建模语言，类的命名尽量用领域中的术语，应明确、无歧义，以利于相互交流和理解。
类的属性、操作中的可见性使用+、#、-分别表示public、protected、private。

3.封装之构造方法

构造方法：
类的构造方法的概念和作用：

• 构造方法负责对象初始化工作，为对象属性赋合适的初始值
• 创建对象时，其类的构造方法确保在用户操作对象之前，系统保证初始化的进行

构造方法的语法规则：

• 构造方法名和类名一致
• 没有返回类型
• 方式实现主要为字段赋值

构造方法的调用：
构造方法的调用很特别：new操作符（实例化对象的时候，自动被调用）

Java系统保证每个类都有构造方法

class Student{//相当于c的结构体
    	private int age;
    	String name;//java中没有指针字符串
    	double score;
	
    	Student(int newAge,String newName,double newScore){//构造方法名与类名一致，且不能有返回值
									//没有返回值，应该是名字前啥也没有，void型也是有返回值的
    		
      System.out.println("构造方法一被调用");
		age = newAge;
		name = newName;
		score = newScore;
	}
	
	Student(int newAge,String newName){
		//Java语言中方法名是可重载的，即函数名一致，参数列表不同。在C中是不允许的
		System.out.println("构造方法二被调用");
		age = newAge;
		name = newName;
	}
	
	Student(){
		System.out.println("构造方法三被调用");
	}
	
	void myPinrtf(){//不用传参，可以直接调用上面的变量，因为面向对象
		System.out.println("age="+age +" name=" +name +" score=" +score);
	}
}


public class Demo2 {
	public static void main(String[] args) {
		Student stu = new Student(21,"zhp",99.9);//通过new操作符实例化类，自动调用构造方法
		stu.myPinrtf();
		Student stu1 = new Student(21,"zhp");
		Student stu3 = new Student();
	}
}

4.this关键字的作用

this关键字的特点：

• 在类的方法中，使用this关键字代表的是调用此方法的对象的引用
• this可以看作是一个变量，它的值是当前对象的引用
• 使用this可以处理方法中的成员变量和形参同名的问题
• 当在方法内需要用到调用到该方法的对象时，就可以用this
• 在类的构造方法中可以调用this（[参数列表]）来调用该类的指定构造方法

class Student{//相当于c的结构体
	private int age;
	String name;//java中没有指针字符串
	double score;
	
	Student(int newAge,String newName){
		//Java语言中方法名是可重载的，即函数名一致，参数列表不同。在C中是不允许的
		System.out.println("构造方法二被调用");
		age = newAge;
		name = newName;
	}
	
	Student(int age,String name,double score){//构造方法名与类名一致，且不能有返回值
									//没有返回值，应该是名字前啥也没有，void型也是有返回值的
		this(19,"zzj");//用this在构造方法中，调用另一个构造方法，只能放在第一句
		System.out.println("构造方法一被调用");
		this.age = age;	//使用this可以处理方法中的成员变量和形参同名的问题
		this.name = name;
		this.score = score;
	}
	
	void myThis(){
		
		Student tmpstu = null;
		tmpstu = this;//this可以看成是一个变量，他的值可以被当前对象引用
		
		System.out.println(tmpstu.age);
		System.out.println(this.name);//使用this关键字调用此方法的对象的引用
	}
	
	void myPinrtf(){//不用传参，可以直接调用上面的变量，因为面向对象
		System.out.println("age="+age +" name=" +name +" score=" +score);
	}
}


public class Demo2 {
	public static void main(String[] args) {
		Student stu = new Student(21,"zhp",99.9);//通过new操作符实例化类，自动调用构造方法
		stu.myPinrtf();
		stu.myThis();
	}
}

5.static关键字

static关键字的特点

• 用来修饰类的成员——修饰成员变量的称为类变量（静态变量）
• 修饰成员方法称之为类方法（静态方法）
• 当类被加载的时候就会被加载，优先于对象的存在
• 用来修饰语句块——称之为静态代码块，先于构造方法之前执行，只会执行一次，用来对静态成员做初始化
• 调用的时候可以直接通过类名.成员来进行访问

static关键字的注意事项：

• 静态方法只能访问外部的静态成员
• 静态方法中不能出现this关键字

class Student{
    	private int age;
    	String name;//java中没有指针字符串
    	double score;   	
    	static int data;//修饰类的成员为静态变量
	
    	Student(int newAge,String newName){
		//Java语言中方法名是可重载的，即函数名一致，参数列表不同。在C中是不允许的
		System.out.println("构造方法");
		age = newAge;
		name = newName;
	}
	
	static{//静态代码块，先于构造方法执行，且只执行一次
		System.out.println("静态代码块");
		data = 10;//用来对静态变量初始化
	}
	
	static void static_test(){
		System.out.println("data = "+data);//静态方法只能访问外部的静态成员
	}
		
}
public class Demo2 {
	public static void main(String[] args) {
		Student stu = new Student(21,"zhp");//通过new操作符实例化类，自动调用构造方法
		Student stu1 = new Student(21,"zhp");
		
		Student.data = 10;//直接通过类名.成员来调用
		Student.static_test();//
		System.out.println("data = "+Student.data);
	}
}

6.包

打包的意义

• 标准Java库是由一系列包组成，包括Java.lang java.util java.net等等。
• 标准Java包就是层次型包结果，就如同硬盘上嵌套的子目录一样，我们可以使用嵌套层次结构来组织包
• Java包是为了更好的规划代码，防止命名冲突和混乱。所以Java出现了打包机制
• 当把类组织起来放进一个包内时，也就给包中的成员赋予了相互访问的权限。你就拥有了该包内的程序代码
• 包访问权限把类聚集在一个包中这一做法提供了意义和理由

一个类可以使用一个包中的所有类
一个类可以使用其他包中所有公开类