1、this关键字

代码示例：

class Student
{
	private int age;
	String name;
	double score;
	
	Student(){   //java语言中，方法（没有返回值）是可重载的，函数名即Student可以一样，但是参数列表不同，这在C语言中确是不允许的
		System.out.println("构造方法1被调用");
	}
	
	Student(int newage, String newname){
		System.out.println("构造方法2被调用");
		age = newage;
		name = newname;
	}
	Student(int age, String name, double score){
		//this(); 这里使用this调用构造方法，只能调用其中一中，不能同时调用多种
		this(12, "we");//5.在类的构造方法中可以调用this([参数列表])来调用该类的指定构造方法，但不能同时调用该类的构造方法
		System.out.println("构造方法3被调用");
		this.age = age; //3.使用this可以处理方法中的成员变量和形参同名的问题
		this.name = name;
		this.score = score;
	}
	void testThis(){
		Student stutmp = null;
		stutmp = this; //2.this可以看作是一个变量，它的值是当前对象(即stu3)的引用
		System.out.println(stutmp.age);
		System.out.println(this.name); //1.在类的方法中，使用this关键字代表的是调用此方法对象的引用
		                               //4.当在方法内需要用到调用到该方法的对象时，就可以用this
	}
	void introduce(){  //方法=函数
		System.out.println("name:"+name+", age:"+age+", score:"+score);
	}
}
public class Demo1 {
	public static void main(String[] args) {
		Student stu3 = new Student(24, "kobe", 89.0);
		stu3.introduce();
		stu3.testThis();
	}
}

运行结果：

构造方法2被调用
构造方法3被调用
name:kobe, age:24, score:89.0
24
kobe

2、static关键字

2.1 static关键字的特点：

（1）用来修饰类的成员 ——修饰成员变量的称为类变量（静态变量）

（2）修饰成员方法称之为类方法（静态方法）

（3）当类被加载时就会被加载（静态方法与静态变量），优先于对象的存在

（4）用来修饰语句块——称之为静态代码块，先于构造方法之前执行，只会执行一次，用来对静态成员做初始化

（5）调用的时候可以直接通过类名.成员来进行访问

2.2 static关键字的注意事项：

（1）静态方法中不能出现this关键字

（2）静态方法中只能访问外部的静态成员

代码示例：

class Student
{
	private int age;
	String name;
	double score;
	
	static int data;
	
	Student(int age, String name, double score){
		System.out.println("构造方法3被调用");
		this.age = age; 
		this.name = name;
		this.score = score;
	}
	
	static{  //用来修饰语句块-称之为静态代码块，先于构造方法之前执行，只会执行一次，用来对静态成员做初始化
		System.err.println("静态代码块"); 
		data = 10;   
		System.err.println("data="+data);
	}
	static void test(){
		//System.out.println(this.age); //1.静态方法中不能出现this关键字
		System.err.println(data); //2.静态方法中只能访问外部的静态成员
	}
	void introduce(){  //方法=函数
		System.out.println("name:"+name+", age:"+age+", score:"+score);
	}
}
public class Demo1 {
	static int add(int data1, int data2){ //当类被加载的时候就会被加载，静态方法也是优先于对象的存在
		return data1 + data2;
	}
	
	public static void main(String[] args) {
		Student stu3 = new Student(24, "kk", 89.0);
		Student.data = 100;  //调用的时候可以直接通过类名.成员来进行访问，同时优先于对象存在即可以不依赖于对象来访问，当类被加载时就会被加载
		Student.test(); //静态成员变量优先于对象存在，静态成员函数亦是是如此
		System.out.println("data="+Student.data);
		System.out.println("ret="+add(8, 24));
	}
}

运行结果：

静态代码块构造方法3被调用

data=10
100
data=100
ret=32

3、方法重载

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

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

4、包（package）

打包的意义：

（1）标准Java库是由一系列包组成，包括java.lang java.util java.net等等

C++的static关键字及变量存储位置总结

pdf 0星 超过10%的资源 56KB

下载

（2）标准Java包就是层次型包结构，就如同硬盘上嵌套的子目录一样，我们也可以使用嵌套层次结构来组织包

（3）Java包是为了更好的规划代码，防止命名冲突和混乱，所以Java出现了打包机制

（4）当把类组织起来放进一个包内时，也就给包中的成员赋予了相互访问的权限，用户就拥有了该包内的程序代码

（5）包权限把该类聚集在一个包中这一做法提供了意义和理由

Java包package----声明

（1）Java程序猿都可以编写属于自己的Java包，为了保证包名唯一性，要求程序猿在自己定义包的名字前加上唯一前缀

（2）由于互联网上的域名称不会重复，所以推荐采用公司在互联网上的域名倒置作为包的唯一前缀

一个类可以使用同一个包中的所有类，一个类可以使用其他包中的所有公开类，使用方法如下：

（1）在每个类签名加上完整包名，例如：java.util.Data today = new java.util.Data()

（2）常用也是更简洁更通用的方式，使用import语句导包(eclipse-->ctrl+shift+o):

import java.util.Data;

...

C++中的static关键字.doc

doc 0星 超过10%的资源 144KB

下载

Data today = new Data();

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

package com.zhangkun.learn中Demo1.java代码：

package com.zhangkun.learn;
import com.zhangkun.use.*;;
public class Demo1 {
	public static void main(String[] args) {
		Demonew Dn = new Demonew();
		Dn.age = 24;
		Dn.name = "zhangkun";
		Dn.printData();
		Dn.printInfo();
		
//		com.zhangkun.use.Demonew Dn2 = new com.zhangkun.use.Demonew();
//		
//		Dn2.name = "zhangkun";
//		Dn2.printData();
//		Dn2.printInfo();
		/*一个类可以使用同一个包中的所有类
		 * 一个类可以使用其它包中的所有公开类(public)
		 * 尽量避免使用同一类名
		 * 使用其它包中的公开类：
		 * 1.com.zhangkun.use.Demonew Dn2 = new com.zhangkun.use.Demonew();加上完整包名
		 * 2.import导入包(eclipse: ctrl+shift+o)
		 * */
	}
}

 运行结果：

同一个包age=24
同一个包name=zhangkun​​​​​​​

package com.zhangkun.learn中Demonew.java代码：

package com.zhangkun.learn;
 
public class Demonew {
	int age;
	String name;
	
	void printData(){
		System.out.println("同一个包age="+age);
	}
	void printInfo(){
		System.out.println("同一个包name="+name);
	}
}

 package com.zhangkun.use中Demonew.java代码： 

package com.zhangkun.use;
 
public class Demonew {
	public String name;
	public int age;
	public void printInfo(){
		System.out.println("name="+name);
	}
	public void printData(){
		System.out.println("age="+age);
	}
}

注意：从Demo1.java中可以看出，在类名相同情况下，import导包想要调用com.zhangkun.use包中的方法，这是无法实现的，编译器默认调用同一个包内的方法，此时import导包无效。若要调用com.zhangkun.use包中方法及成员变量，必须添加完整的包，即：com.zhangkun.use.Demonew Dn2 = new com.zhangkun.use.Demonew();