JAVA学习笔记（二）Java的类、封装、this、static关键字、方法重载、包

一、类的封装

• 封装的概念：
  将东西包在一起，然后以新的完整形式呈现出来
  将方法和字段一起包装到一个单元中，单元以类的形式实现

• 信息隐藏，隐藏对象的实现细节，不让外部直接访问到

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

“定义类，定义其属性、方法的过程称为封装类”

• 类=模板，类不能直接使用，不能直接访问变量，需要先实例化，申请一个空间。
• 如果没有实例化Student stu1 = null;会出现段错误，就好比C语言里，定义了一个野指针，然后去访问指针里的变量，会出现段错误，必须先malloc申请一个空间才行。

示例：

class Student{
		int age;
		String name;
		double score;
		
		void introduce(){
			System.out.println("name:"+name+" age:"+age+" score:"+score);
		}
		void testFunc(){
			System.out.println("testFunc");
		}
	};
public class Demo {
	
	public static void main(String[] args) {
		Student stu1 = new Student();//实例化一个对象
		//Scanner sc = new Scanner(System.in);
		//a = sc.nextInt();
		stu1.age = 19;
		stu1.name = "hello world";
		stu1.score = 90.6;
		stu1.introduce();
		stu1.testFunc();
	}
}

访问修饰符

• 访问修饰符：private、protected、public、默认
  public:该类或非该类均可以访问
  private:只有该类可以访问
  protected:该类及其子类的成员可以访问，同一个包中的类也可访问
  默认：同一个包中的类可以访问

位置	private	默认	protected	public
同一个类	是	是	是	是
同一个包内的类	否	是	是	是
不同包内的子类	否	否	是	是
不同包并且不是子类	否	否	否	是

• 属性封装的实现：
  修改属性的可见性来限制对属性的访问
  为每个属性创建一对赋值方法（setter）和取值(getter)方法，用于公开对这些属性的访问接口
  在setter和getter方法中，根据需要加入对属性操作的限制
  
• 方法封装的目的：
  隐藏方法实现细节（方法体），向外部提供公开接口（方法头），以供安全调用
  简化调用，方便修改维护
  根据需要，可以私有化方法，以供内部使用—帮助方法helper
  

示例：

class Student
{
		private int age;
		String name;
		double score;
		private int sex;
		
		private void myage(int myage){
			age = myage;
		}
		public int getage(){
			myage(18);
			return age;
		}
		public void setage(int set){
			age = set;
		}
		void changesex(int change){
			sex = change;
		}
		public int getsex(){
			return sex;
		}
		void introduce(){
			System.out.println("sex:"+sex+" name:"+name+" age:"+age+" score:"+score);
		}
		void testFunc(){
			System.out.println("testFunc");
		}
};
public class Demo {
	
	public static void main(String[] args) {
		Student stu1 = new Student();
		//stu1.age = 19;
		stu1.setage(36);
		stu1.name = "hello world";
		stu1.score = 90.6;
		stu1.changesex(10);
		stu1.introduce();
		System.out.println("sex="+stu1.getsex()+" age="+stu1.getage());
		stu1.testFunc();
	}
}

运行结果

sex:10 name:hello world age:36 score:90.6
sex=10 age=18
testFunc

二、UML类图

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

三、构造方法

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

• 构造方法的语法规则:
  (1)构造方法名与类名一致
  (2)没有返回类型
  (3)方式实现主要为字段赋初值 *构造方法可以有多个，调用哪个取决new的时候参数个数
  构造方法的调用

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

示例：

class Student
{
		private int age;
		String name;
		double score;
		
		Student(){//java语言中，方法是可重载的，函数名一样，参数列表不同，在C中是不允许
			System.out.println("构造方法一被调用");
		}
		Student(int newage,String newname){
			System.out.println("构造方法二被调用");
			age = newage;
			name = newname;
		}
		Student(int newage,String newname,double newscore){
			System.out.println("构造方法三被调用");
			age = newage;
			name = newname;
			score = newscore;
		}
}

public class Demo2 {
	public static void main(String[] args) {
		Student stu1 = new Student(18,"hello world",100);
		Student stu2 = new Student(18,"hello world");
		Student stu3 = new Student();
	}
}

四、this关键字的特点

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

示例：

class Student
{
		private int age;
		String name;
		double score;
		
		Student(){//java语言中，方法是可重载的，函数名一样，参数列表不同，在C中是不允许
			System.out.println("构造方法一被调用");
		}
		Student(int newage,String newname){
			System.out.println("构造方法二被调用");
			age = newage;
			name = newname;
		}
		Student(int age,String name,double score){
			//this();
			this(19,"hello");//第五条
			System.out.println("构造方法三被调用");
			this.age = age; //第三条
			this.name = name;
			this.score = score; 
		}
		void testThis(){
			Student stutmp = null;
			stutmp = this; //第二条
			System.out.println(stutmp.age);
			System.out.println(this.name);
		}
}

public class Demo2 {
	public static void main(String[] args) {
		Student stu1 = new Student(18,"hello world",100);
		stu1.testThis();//第一条
	}
}

运行结果

构造方法二被调用
构造方法三被调用
18
hello world

五、static关键字的使用

static关键字的特点：

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

注意事项:
静态方法中只能访问外部的静态成员
静态方法中不能出现this关键字

示例：

class Student
{
		private 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;
		}
		
		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+" socre="+score);
		}
}

public class Demo2 {
	public static void main(String[] args) {
		Student stu1 = new Student(18,"hello world",100);
		Student stu2 = new Student(18,"hello world",100);
		stu1.score = 10;
		Student.data = 10;//类变量，类名.成员来进行访问
		//Demo2 d = new Demo2();
		System.out.println("a+b="+add(1,3));
	}
	static int add(int a,int b){
		return a+b;
	}
}

示例：

六、方法重载

• 多数程序设计语言要求为每个方法（函数）提供一个独一无二的方法名，不存在方法重载的概念。
• 在java中，规定方法签名是解析方法的规则而不是方法名，为方法重载开创了条件。
• 方法重载使得在一个类中，方法名相同而参数列表不同的方法可同时存在，代表相似的行为或功能。

重载overload概念：同一个类中，同名不同参的方法称为重载方法
注意：仅有返回值不同的方法不能称为重载。

• 方法重载并不陌生，Java.io.PrintStream类的println方法能打印数据，根据数据类型不同，有不同的实现方式
  

七、包（package）

打包的意义：

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

Package—声明包

• Java程序员都可以编写属于自己的Java包，为了保证包名唯一性，要求程序员在自己定义包的名字前加上唯一前缀。
• 由于互联网上的域名称不会重复，所以推荐采用公司在互联网上的域名的倒置作为包的唯一前缀。
• 一个类可以使用同一个包中的所有类
• 一个类可以使用其它包中的所有公开类
  
  怎么使用其它包中的公开类
  在每个类签名加上完整包名，例如：

java.util.Data today = new java.util.Date();

更简洁更通用的方式：使用 improt 语句来导包（eclipse ctrl+shift+o）

import java.util.Date;
··········
Date today = new Date();

可以 import 特定类，也可以导入整个包。通过在源代码文件的顶部（在打包语句后）使用 import 语句来实现 import java.util.*;

同包不同类

package com.hello.learn;

public class Demo3 {
	public static void main(String[] args) {
		Demonew dm = new Demonew();//同一个包可以直接调用
		dm.age = 10;
		dm.printfdata();
		
		com.hello.use.Demonew dm2 = new com.hello.use.Demonew();//不同包需要添加路径或者使用 import 语句来实现比如:import com.hello.use.*;
		dm2.name = "dm2";
		dm2.printinfo();
	}
}

package com.hello.learn;

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

不同包

package com.hello.use;

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

运行结果

age=10
name = dm2