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	默认	prtected	public
同一个类	是	是	是	是
同一个包内的类	否	是	是	是
不同包内的子类	否	否	是	是
不同包并且不是子类	否	否	否	是

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

java封装：构造方法

类的构造方法的概念和作用
构造方法负责对象初始化工作，为对象的属性赋合适的初始值。
创建对象时，其类的构造方法确保在用户操作对象之前，系统保证初始化的进行。
构造方法的语法规则
构造方法名与类名一致
没有返回类型
方式实现主要为字段赋初值
构造方法的调用
构造方法的调用很特别：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关键字的使用

this关键字的特点
在类的方法中，使用this关键字代表的是调用此方法的对象的引用。
this可以看做是一个变量，它的值是当前对象的引用。
使用this可以处理方法中的成员变量和形参同名的问题
当在方法内需要用到调用到该方法的对象时，就可以用this
在类的构造方法中可以调用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关键字的特点
用来修饰类的成员——修饰成员变量的称为类变量（静态变量）
修饰成员方法称之为类方法（静态方法）
当类被加载的时候就会被加载，优先于对象的存在
用来修饰语句块——称之为静态代码块，先于构造方法之前执行，只会执行一次，用来对静态成员做初始化。
调用的时候可以直接通过类名.成员来进行访问。
static关键字的注意事项
静态方法中只能访问外部的静态成员
静态方法中不能出现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