一、包
package p;
public class SamePack {
public static void main(String[] args) {
}
}
1、包的作用与声明
/*
包:包类似于操作系统中的文件夹。(类似,不是等同)
包的作用:
1 包可以提供文件(.class)的分类管理。
2 包可以提供独立的命名空间,进而解决命名冲突。
3 包可以提供访问权限的控制,实现更好的封装。
包的声明:
package 包的名字。
以前我们没有显式的声明包,则文件处于无名包中。
包也可以具有层次性,包与包之间,包与类之间,使用
.进行分隔。
包声明的要求:
1 位置:包声明必须是源文件中第一条有效的语句。
2 数量:最多只能有一条包声明语句。
当显式声明包时,编译与运行与之前的细微变化:
编译: javac -d class文件的路径 源文件.java
运行: java 类的全限定名(包名 + 类名)
当两个类(A与B)处于同一个包中时,在A类型中
可以通过简单名来访问B。
当两个类(A与B)不在同一个包中时,则不能通过
简单名进行访问。此时,可以:
1 使用类的全限定名访问。
2 导入该类型,然后就可以通过简单名来访问。
import
import 类的全限定名;
import使用规则:
1 位置:import语句必须出现在包声明之后,类型
声明之前。
2 数量:import语句可以有0条到多条。
import 包名.*; 导入该包中所有的类型。(按需导入)
按需导入仅会导入当前包中的所有类型,不包括子包
中的类型。
import 包名.子包.*;
java.lang包中的所有类会由编译器隐式的导入。
import java.lang.*;
*/
package p;
//package p.subp;
import p2.DiffPack;
public class PackageTest {
public static void main(String[] args) {
//System.out.println("Hello World!");
//在同一包中,可以通过简单名来访问一个类。
new SamePack();
//不在同一个包中,不能通过简单名访问。
//new DiffPack();
//使用类的全限定名访问包外的类
new p2.DiffPack();
//通过import导入该类型后,可以使用类的简单名进行访问。
new DiffPack();
}
}
//错误。
//package p;
2、静态导入
/*
import static 静态导入
import与import static
import是导入一个(多个)类型,而import static
导入的是一个类型的成员(静态成员)。
当使用import static导入静态成员后,就可以直接
使用该静态成员(无需通过类名限定),就好像该
静态成员是当前类中所声明的一样。
*/
import static java.lang.Math.sqrt;
import static java.util.Arrays.*;
public class ImportStatic {
public static void main(String[] args) {
int x = 100;
System.out.println(Math.sqrt(x));
//直接访问静态成员,就像本类中声明的一样。
System.out.println(sqrt(x));
int[] k = {5, 4, 3, 2, 1};
sort(k);
}
}
3、
package in;
/*
在类的内部,可以访问任意访问权限的成员变量。
因为在创建对象的时候,会自动调用构造器。
如果构造器没有访问权限,我们就无法成功创建对象。
*/
public class PublicAc {
public int pubX;
int defX;
private int priX;
public void f() {
pubX = 1;
defX = 1;
priX = 1;
pubM();
defM();
priM();
new PublicAc();
new PublicAc(1);
new PublicAc(1, 1);
}
public PublicAc() {
}
PublicAc(int x) {
}
private PublicAc(int x, int y) {
}
public void pubM() {
}
void defM() {
}
private void priM() {
}
}
class DefAc {
}
4、访问修饰符
访问修饰符用来声明访问权限,访问权限由高到低为:
public 共有权限,全部对外开发。
protected 保护权限,对本包开放,对包外的子类开放。
不加修饰符限定 默认权限,对本包开放。
private 私有权限,仅对本类开放。
说明:
关于protected访问权限,推迟到继承的时候再说。
访问修饰符可以修饰类(接口),方法,成员变量,构造器。
/*
顶层类的访问权限可以是public与默认访问权限。
不可以是protected与private访问权限。
内部类可以是任意的访问权限。
在同一个包中,可以访问本包中声明为public,默认
访问权限的类。
在包外,可以访问声明为public访问权限类型。
*/
package in;
import out.*;
/*
在类的外部,包的内部(同一个包中),可以访问
声明为public, 默认访问权限的成员,不能访问
声明为private访问权限的成员。
*/
public class Access {
public static void main(String[] args) {
PublicAc p;
DefAc d;
PublicOut p2;
//DefOut d2;
PublicAc pa = new PublicAc();
pa.pubX = 1;
pa.defX = 1;
//pa.priX = 1;
pa.pubM();
pa.defM();
//pa.priM();
new PublicAc();
new PublicAc(1);
//new PublicAc(1, 1);
}
}
5、static 关键字
/*
static关键字
static可以修饰类(内部类),成员变量,方法。
局部变量不能使用static修饰。
当static修饰成员变量时,该变量称为静态成员变量。
没有使用static修饰的成员变量称为实例成员变量。
当static修饰方法时,该方法称为静态方法。
没有使用static修饰的方法称为实例方法。
静态成员变量与实例成员变量
1 变量的数量
静态成员变量为整个类所有(整个类只有一个),如果
一个对象改变了静态成员变量的值,将会影响到其他对象
(其他对象看到的将是修改之后的结果)。
实例成员变量为对象所有,每个对象都有自己的实例成员
变量,一个对象改变了实例成员变量的值,对其他对象
没有影响。
2 变量的访问方式
静态成员变量既可以通过对象的引用进行访问(强烈不建议),
也可以通过类名进行访问。
实例成员变量只能通过对象的引用进行访问。
3 初始化的时间
静态成员变量会随着类的初始化而初始化。
实例成员变量在创建对象时得到初始化。
静态成员变量的初始化时间要早于实例成员变量。
*/
public class Static {
//实例成员变量
int x = 1;
//静态成员变量
static int y = 2;
public static void main(String[] args) {
Static s = new Static();
Static s2 = new Static();
s.x = 100;
//System.out.println(s2.x);
//通过引用访问静态成员变量。(不推荐)
s.y = 200;
System.out.println(s2.y);
//通过类名访问静态成员变量。
Static.y = 200;
}
}
6、
/*
static修饰方法
静态方法与实例方法
1 方法的访问方式
静态方法既可以通过对象的引用来访问(强烈不推荐),
也可以通过类名来进行访问。
实例方法只能通过对象的引用进行访问。
2 成员的访问限制
静态方法只能访问静态成员(静态成员变量,静态方法等)。
实例方法既可以访问静态成员,也可以访问实例成员。
3 this与super
静态方法中不能使用this与super。
实例方法中可以使用this与super。
*/
public class Static2 {
int x = 1;
static int y = 2;
//实例方法
public void f() {
x = 1;
y = 2;
g();
staticF();
}
public void g() {
}
//静态方法
public static void staticF() {
//错误,静态方法不能访问实例成员。
//x = 1;
//g();
y = 2;
staticG();
//Static2.staticG();
}
public static void staticG() {
}
public static void main(String[] args) {
Static2.staticF();
/*
Static2 s = new Static2();
s.f();
//通过引用访问静态方法(不推荐)
s.staticF();
//通过类名访问静态方法
Static2.staticF();
*/
}
}
7、
/*
静态成员变量的初始化
1 在变量声明处初始化
2 使用静态初始化块
两种初始化执行顺序与在类中声明的顺序一致。
(先声明的先执行)
*/
public class StaticInit {
//静态初始化块
//在类初始化时会得到执行。
static {
//x = 5;
System.out.println("静态初始化块执行");
}
//static int x = initX();
static int x;
public StaticInit() {
x = 100;
}
public static int initX() {
System.out.println("x初始化执行");
return 1;
}
public static void main(String[] args) {
System.out.println(x);
}
}
8、final 关键字
/*
final可以修饰成员变量,局部变量,方法,类。
final修饰变量,该变量一经赋值,就不能够再进行修改。
final修改变量,该变量就会成为常量。
*/
public class FinalTest {
//final修饰成员变量时,需要进行显式的初始化,
//不可以拿默认值作为初始值。
final int k;
{
//k = 2;
}
public FinalTest(int k) {
this.k = k;
}
public static void main(String[] args) {
final int x = 1;
//x = 2;
//final修饰一个局部变量,没有初始值,只要不使用
//该变量,就没有问题。
final int y;
//x = 1;
final int[] a = {1, 2, 3, 4, 5};
a[0] = 1000;
System.out.println(a[0]);
//a = #0x2345;
//a = new int[3];
//a = null;
}
public void f(final int k) {
//错误
//k = 2;
}
}
9、
/*
final修饰变量的好处:
1 使用final修饰变量,可以防止变量被意外的进行修改。
2 使用final可以避免魔幻数字的产生,增加程序的可读性。
3 使用final可以提高程序的可维护性。
*/
public class FinalAd {
final int WIDTH = 10;
final int HEIGHT = 5;
public void compute() {
//int area = 10 * 5;
int area = WIDTH * HEIGHT;
}
}
10、private
/*
类的封装
隐藏底层的实现细节,将类中声明的成员变量私有化(private)。
提供公有getter与setter方法,供外界进行间接访问。
getter 获取成员变量的值。
setter 设置成员变量的值。
*/
public class Private {
//int x; => int x2;
private int x2;
public int getX() {
return x2;
}
public void setX(int x) {
this.x2 = x;
}
}
class Another {
public void access() {
Private p = new Private();
//p.x = 1;
p.setX(1);
//System.out.println(p.x);
System.out.println(p.getX());
}
}