一、包

Java中的包等同于C#中的命名空间，它是类的上一级结构。

  1. 定义包：package 包名;
  2. 导入包

包导入语句

导入效果

import 包名.*

导入包中所有文件

import 包名.类名

导入包中的指定类

PS. 还可以在程序中直接通过包名.类名进行调用。

注意：

  1. 建议采用“import 包名.类名”的方式加载，提高效率；
  2. 加载类的顺序与import导入的顺序无关；
  3. “import 包名.* ”只能访问包名下的类，无法访问子包下的类。

二、访问权限

同一个类

同一个包

不同包的子类

不同包的非子类

private

✓

默认

✓

✓

protected

✓

✓

✓

public

✓

✓

✓

✓

package com.h.test;

public class Test {
	private int varPrivate = 0;
	int varDefault = 1;
	protected int varProtected = 2;
	public int varPublic = 3;
	
	public void myTest() {
		// 同类
		System.out.println(this.varPrivate);
		System.out.println(this.varDefault);
		System.out.println(this.varProtected);
		System.out.println(this.varPublic);
	}
	
}
package com.h.test;

public class Test2 {

	public void myTest() {
		// 同包非子类
		Test test = new Test();
		System.out.println(test.varPrivate);	// 编译报错
		System.out.println(test.varDefault);
		System.out.println(test.varProtected);
		System.out.println(test.varPublic);
	}

}
package com.h.test;

public class Test3 extends Test{
	
	public void myTest() {
		// 同包子类
		Test test = new Test();
		System.out.println(test.varPrivate);	// 编译报错
		System.out.println(test.varDefault);
		System.out.println(test.varProtected);
		System.out.println(test.varPublic);
		
		System.out.println(this.varPrivate);	// 编译报错
		System.out.println(this.varDefault);
		System.out.println(this.varProtected);
		System.out.println(this.varPublic);
	}
}
package com.h.test2;

import com.h.test.Test;

public class Test4 {
	
	public void myTest() {
		// 不同包非子类
		Test test = new Test();
		System.out.println(test.varPrivate);	// 编译报错
		System.out.println(test.varDefault);	// 编译报错
		System.out.println(test.varProtected);	// 编译报错
		System.out.println(test.varPublic);
	}

}
package com.h.test2;

import com.h.test.Test;

public class Test5 extends Test {

	public void myTest() {
		// 不同包子类
		Test test = new Test();
		System.out.println(test.varPrivate);	// 编译报错
		System.out.println(test.varDefault);	// 编译报错
		System.out.println(test.varProtected);	// 编译报错
		System.out.println(test.varPublic);
		
		System.out.println(this.varPrivate);	// 编译报错
		System.out.println(this.varDefault);	// 编译报错
		System.out.println(this.varProtected);
		System.out.println(this.varPublic);

	}

}

综上所述：

  • private只允许在同类中进行访问；
  • default允许同类、同包中访问；
  • protect允许在同类、同包、不同包子类中访问；
  • public允许在同类、同包、不同包中进行访问。

三、关键字

  1. static（静态）
  • static不能修饰类、方法里的局部变量；
  • 静态方法不能直接访问同一个类中的非静态成员，只能直接调用同一个类中的静态成员，但可通过实例化进行访问非静态成员；
  • 静态方法中不能使用this；
  • 静态方法不允许在子类中重写。
  1. final
  • final不能修饰构造方法；
  • 使用final修饰的类，没有子类，不能被继承；
  • 使用final修饰的方法，不能被子类重写，可以正常被子类继承使用；
  • 使用final修饰的变量，只要在使用前赋值即可，一旦赋值不能改变，即常量。
  • 定义初始化
  • 构造代码块中赋值
  • 构造方法中赋值
  1. this和super

this

super

访问当前类的成员方法

访问父类的成员方法

访问当前类的成员属性

访问父类的成员属性

访问当前类的构造方法

访问父类的构造方法

不能在静态方法中使用

不能在静态方法中使用

四、 定义

  • 类：抽象的概念，是一个模板。
  • 对象：类的实例化，是一个具体实体。
  • 属性：对象具有的各项静态特征，代表着“有什么”。
  • 方法：对象具有的各项动态行为，代表着“做什么”。

五、类与对象

  1. 类的创建：修饰符 class 类名{}
public class Test{

}
  1. 对象的声明与实例化：
    类名 对象名 => 在栈空间中创建空对象
    new 类名() => 在堆空间中开辟了一个新的实例空间
Test test = new Test();

六、属性与方法

属性与方法的定义等同于变量与方法的定义。

public class Test{
	public int varTest;
    
    public void myTest(){
        
    }
}

七、构造方法

和普通方法不同，构造方法只能在类被实例化的时候进行调用。因此，构造方法常被用于初始化类。

构造方法根据是否带有参数分为无参构造方法和带参构造方法。

构造方法的结构为：

public class TestSample {
	String name;
    
    // 无参构造方法
	public TestSample() {
		
	}
	
    // 带参构造方法
	public TestSample(String name) {
		this.name = name;
	}
}

定义构造方法时需注意：

  • 构造方法与类同名且没有返回值
  • 当类中没有指定构造方法时，系统会自动添加无参的构造方法
  • 当有指定构造方法时，无论是带参、无参的构造方法，都不会自动添加无参的构造方法
  • 一个类中可以有多个构造方法
  • 构造方法之间可以通过 this() 或 this(参数) 进行调用，但只能放在第一条语句处
  • 在构造方法中可以调用类的成员属性和成员方法
  • 子类构造方法默认调用父类的无参构造方法，子类可以通过super() / super(参数)调用父类允许被访问的构造方法，但必只能放在第一条语句处

八、代码块

  1. 普通代码块：定义于方法中的{}。
    执行顺序：顺序执行，先出现，先执行。
public void myTest() {
    {
        System.out.println("普通代码块1");
    }

    System.out.println("普通方法");

    {
        System.out.println("普通代码块2");
    }
}
  1. 构造代码块：定义于类中，没有加static关键字的代码块{}。
    执行顺序：创建对象（实例化）时调用，优先于构造方法执行。（每次创建对象都会被调用）
{
    System.out.println("构造代码块");
}
  1. 静态代码块：定义于类中，加以关键字static进行修饰的代码块。
    执行顺序：类加载时调用，优先于构造代码块执行。（每个静态代码块只执行一次）
static{
    System.out.println("静态代码块");
}

因此，整合上述代码，可得执行效果如下：

package com.h.test3;

public class TestSample {
	static{
		System.out.println("静态代码块");
	}
	
	{
		System.out.println("构造代码块");
	}
	
	public TestSample() {
		System.out.println("构造方法");
	}
	
	public void myTest() {
		{
			System.out.println("普通代码块1");
		}
		
		System.out.println("普通方法");
		
		{
			System.out.println("普通代码块2");
		}
	}
}
package com.h.test3;

public class TestMain {

	public static void main(String[] args) {
		TestSample testSample = new TestSample();
		testSample.myTest();

	}

}
/* 执行结果如下：
	静态代码块
	构造代码块
	构造方法
	普通代码块1
	普通方法
	普通代码块2
*/