JAVA 封装

封装的概念

信息隐藏，隐藏对象的实现细节，不让外部直接访问到
属性可用来描述同一类事物的特征，方法可描述一类事物可做的操作。封装就是把属于同一类事物的共性（包括属性与方法）归到一个类中，加上具体事项的隐藏（访问修饰符）以方便使用。

访问修饰符
1：public
只有当前类、同一包内、子孙类(同一包)、子孙类(不同包) 其他包都能够访问
2：protected
其他包不能够访问
3：default
子孙类(不同包) 其他包不能访问
4：private
子孙类(同一包) 子孙类(不同包) 其他包不能访问

属性封装的实现
为每个属性创建一个赋值方法和取值方法，用于公开这些属性的访问接口

方法封装的目的
隐藏方法实现的细节（方法体），向外部提供公开接口（方法头），以供安全调用简化调用，方便修改维护

封装实例

import java.security.PublicKey;

class Student
{
	
	private int age; // 成员 不可见
	String name;
	double score;
	private int sex = 0;
	
	private void myage(int myage){// 方法封装
		
		age = myage;
	}
	
	public int getage(){ // 访问私有成员
		myage(18);
		return age;
	}
	
	public void setage(int realage){
		
		age = realage;
	}
	
	
	public void changeSex(int finalSex){ // 方法 =函数 通过方法间接访问隐藏的成员
		sex = finalSex;
		
	}
	
	void introduce(){
		System.out.println("sex="+sex+",name="+ name +",age=" + age + ",score=" + score);

	}
	void Test(){
		System.out.println("Holle World!");
		
	}
}


public class Demo1 {
	public static void main(String[] args) {
		Student Stu = new Student(); // 实例化一个对象(申请空间) 类不能直接使用 要实例化申请空间
		Stu.setage(50);
	//	Stu.age = 30;
		Stu.name = "linruimiao";
		Stu.score = 95.5;
 		Stu.changeSex(1);
	
	//	Stu.getage();
		Stu.introduce(); //直接访问
		Stu.Test();
		System.out.println("age=" + Stu.getage()); // 调用私有方法
	}
}

UML类图

UML是统一建模语言，是一种可视化的面向对象建模语言，是一种用来对真实世界物理进行建模的标准标记，用图形方式表现典型的面向对象系统的整个结构。它的作用域不局限于支持面向对象的分析与设计，还支持从需求分析开始的软件开发的全过程。
类的命名尽量应用领域中的术语，应明确、无岐义，以利于相互交流和理解。类的属性、操作中的可见性使用+、#、－分别表示public、protected、private。

构造方法

构造方法是一种特殊的方法，它是一个与类同名的方法。对象的创建就是通过构造方法来完成，其功能主要是完成对象的初始化。当类实例化一个对象时会自动调用构造方法。构造方法和其他方法一样也可以重载。
特点
JAVA保证每个类都有构造方法
构造方法的名字必须与定义他的类名完全相同，没有返回类型，甚至连void也没有。
调用方法：new操作符（实例化对象时 自动调用）

class Student
{
	int age; 
	String name;
	double score;

	Student(){// java中 方法可重载  函数名一样 参数列表不同 c语言不允许
		System.out.println("构造方法2");
	}
	
	Student(int newage, String newname, double newscore){
		System.out.println("构造方法1");
		age = newage;
		name = newname;
		score = newscore;		
	}
	Student(String newname, double newscore){
		System.out.println("构造方法3");
		name = newname;
		score = newscore;		
	}
	
	void introduce(){
		System.out.println("name="+ name +",age=" + age + ",score=" + score);

	}
}

public class demo1 {
	public static void main(String[] args) {
		Student stu1 = new Student(18, "linruimiao", 72.5);
		Student stu2 = new Student("linruimiao", 80.5);
		Student stu3 = new Student();
		stu1.introduce();
		
	}

}

this关键字的使用

用法：

1. 在类的方法中，使用this关键字代表的是调用此方法的对象的引用
2. this可以看做一个变量，他的值是当前对象的引用
3. 在类的构造方法中可以调用this来调用该类的制定构造方法（只能放在第一句）
4. 使用this可以处理方法中的成员变量和形式参数同名的问题（主要）

class Student
{
	int age; // 成员
	String name;
	double score;
	Student(){// java中 方法可重载  函数名一样 参数列表不同 c语言不允许
		System.out.println("构造方法2");
	}
	
	Student(String newname, double newscore){
		System.out.println("构造方法3");
		name = newname;
		score = newscore;		
	}
	
	Student(int age, String name, double score){
		//this();
		this("lrm",52.2);//在类的构造方法中可以调用this来调用该类的制定构造方法
		this.age = age;
		this.name = name;
		this.score = score;//使用this可以处理方法中的成员变量和形式参数同名的问题
		
	}

	void thisThis(){
		System.out.println(this.name);//在类的方法中，使用this关键字代表的是调用此方法的对象的引用
		Student stutmp = null;
		stutmp = this;
		System.out.println(stutmp.age);//this可以看做一个变量，他的值是当前对象的引用
	}
	
	void introduce(){
		System.out.println("name="+ name +",age=" + age + ",score=" + score);

	}
}

public class demo {
	public static void main(String[] args) {
		Student stu1 = new Student(18, "linruimiao", 72.5);

		stu1.introduce();
		stu1.thisThis();
	}

}

static关键字的使用

特点

1. 用来修饰类的成员 称为类变量（静态变量）
2. 修饰成员方法的类方法（静态方法）
3. 当类被加载时加载 优先于对象存在
4. 静态代码块只能调用一次 优先于对象存在 用来对静态成员初始化

注意：

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

class Student
{
	int age; // 成员
	String name;
	double score;
	
	static int data;//用来修饰类的成员 称为类变量（静态变量）
	
	
	Student(int age, String name, double score){
		System.out.println("构造方法");
		this.age = age;
		this.name = name;
		this.score = score;//使用this可以处理方法中的成员变量和形式参数同名的问题
		
	}

	static{ //静态代码块只能调用一次  优先于对象存在 用来对静态成员初始化
		System.out.println("静态代码块");
		data = 100;
	}
	
	static void test(){
	//	System.out.println(this.age); // 静态方法不能出现this关键字
		System.out.println(data); // 静态方法只能访问外部的静态成员
	}
	
	void introduce(){
		System.out.println("name="+ name +",age=" + age + ",score=" + score);
		
	}
}

public class demo1 {
	public static void main(String[] args) {
		Student stu1 = new Student(18, "linruimiao", 72.5);
		Student stu2 = new Student(18, "linruimiao", 72.5);
		stu1.test();
		Student.data = 10;
		System.out.println("ret="+add1(1, 5));
		
		demo1 d = new demo1();
		System.out.println("ret="+d.add2(1,2));
		stu1.introduce();
		stu1.test();
	}
	
	static int add1(int a,int b){//修饰成员方法的类方法（静态方法） 当类被加载时加载 优先于对象存在
		return a+b;
	}
	int add2(int a,int b){
		return a+b;
	}
}

方法重载

方法重载的定义：在一个类中有两个方法，他们具有相同的名字，但有不同的参数列表。
也就是说，方法名（等同于函数名）可以相同，只要保证形参类型不同就可以了
多数语言不行 JAVA支持

包

概念：用于区别类名的命名空间，是一种更好的组织类的机制。
作用：
1、把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
2、如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
3、包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

为了保证包名的唯一性，要求程序猿在自己定义包的名字前加一个前缀
由于互联网上的域名称不会重复，所以推荐采用公司在互联网上域名的倒置作为包的唯一前缀
一个类可以使用同一个包中的类，也可以使用不同包中的公开的类
使用公开类：
1 在每个类前加上完整的包名：
2. 使用import语句（Shift+Ctrl+o）

package com.linruimiao.learn; //不可省

import cpm.linruimiao.use.Demo;


public class demo1 {
	public static void main(String[] args) {
		demonew dm = new demonew();
		dm.name = "linruimioa";
		dm.printinfo();
		cpm.linruimiao.use.demonew dm2 = new cpm.linruimiao.use.demonew(); //避免两个同样的类名 虽然可以这么用
		dm2.name = "linruimioa"; 
		dm2.printinfo();
		Demo dm3 = new Demo(); 
		dm3.age = 18;
		dm3.printAge();
	}
}

package com.linruimiao.learn;


public class demonew {
	public String name;
	public void printinfo(){
		System.out.println("1name="+name);
	}
}

package cpm.linruimiao.use;

public class Demo {
	public int age;
	public void printAge(){
		System.out.println("age="+age);
	}
}

package cpm.linruimiao.use;



public class demonew {
	public String name;
	public void printinfo(){
		System.out.println("2name="+name);
	}
}