static

静态成分

静态的成员变量-类变量

static修饰的成员属于类所有，是所有实例（对象）所共享的成员。

成员变量可以是任何变量（可以是另一个类）
引用

（推荐）：类名称.变量名
- （不推荐）：对象名称...

作用：
通常用来提供共享的数据或工具方法如：Math.PI

静态的成员方法-类方法

引用

（推荐）：类名称.方法名
- （不推荐）：对象名称...

静态变量和静态方法在加载字节码的时候就进行处理，分配早
（实例变量和实例方法在创建对象的时候处理）
具体过程：

静态方法能调用静态变量和其他静态方法。
静态方法不能直接使用非静态变量和方法。只能创建对象后，通过对象调用。
实例方法可以调用所有方法和变量

静态代码块

static{
	System.out.println("Static block....");
}

在加载类的字节码时候，输出一次

package与import

什么是package?

逻辑上： 包是类的集合，一个包中含多个类(同包内，类不重名）
物理存储上： 包是类的组织方式，一个包对应一个文件夹。
包名体现类与接口的目录结构，用“”进行分隔。
包与类的关系： 类似文件夹与文件的关系
优点：

方便代码重用
可以将一组相关的类或接口封装在包（package）里，从而更好地管理已经开发的Java代码

取名：使用域名的模式

例如：cn.sdut.cs
物理路径（文件夹）上表现为：文件夹cn->文件夹sdut->文件夹cs

import(不同包的调用)

不同包的类，需要用import导入类
注意：
　对于default package：不能被其他包调用；所以尽量不要放在default package
如果要引用一个包的多个类：import xxx.*
对于java.long包可以不用import

包名严格区分

举例：cn.sdut包与cn.sdut.cs包是完全不同的包
2个包不具备包含关系（与文件夹的含义不同）
cn.sdut.A类使用cn.sdut.cs.B类时，要导入包
cn.sdut.cs.B类使用cn.sdut.A类时，也要导入包
第3个包要访问cn.sdut.cs.B类时，
import cn.sdut.cs.；或者import cn.sdut.cs.B；均可
import cn.sdut.; 是错误的

访问修饰符

分类：4个

访问修饰符：private（私有）默认 protected（受保护的） public（公开）

注意：只能不能访问变量；变量一样生成，一样占用空间

private

private可以修饰构造方法：（枚举类）
可以修饰普通变量：可以被继承，占用内存，但是不能访问

实践protected

package cn.sdut.cs2;

import cn.sdut.cs1.A;

//D类是A类的非同包子类
public class D extends A {
	
	public void d_m1()
	{
		System.out.println(c);
		//（c是A中的具有protected权限的数据）
		//可以正常输出
		System.out.println(d);
	}
	
	public static void main(String[] args) {
		D obj = new D();
		System.out.println(obj.c);
		//（c是A中的具有protected权限的数据）
		//可以正常输出

		
		A obj2 = new A();
		System.out.println(obj2.c);
		//（c是A中的具有protected权限的数据）
		//""""不""""可以正常输出
	}
}

目的：

信息隐藏（是OOP的最重要的功能之一，也是使用访问修饰符的原因。）
控制非法输入

实现方法：创建输出输出函数

代码：

public class Point2 {
 private int x;
//创建隐性变量：其他类不可直接访问该变量
//直接访问显示错误
 private int y;
 private int age;

public int getX() {
	return x;
}
//需要创建函数输出
public int getAge() {
	return age;
}

public void setX(int x) {
	this.x = x;
}
//需要创建函数输出
public void setAge(int age) {
this.age = age;
}

abstract（抽象的）

修饰：类和方法
抽象方法：
提供方法的声明，但不提供方法体
例：

public abstract int area();

含有抽象方法的类一定是抽象类
抽象类：
不能用来生成对象，只能被继承（普通类必须继承全部的方法）
子类继承后实现未完成的抽象方法，否则为抽象类。
快速构建抽象类

对象的组合

举例：

public class Cuboid {
    SS rect;
    int c;
    public int totaArea()
    {
    	return 2*rect.length()*c+2*rect.area();
    }
    public int volumn()
    {
    	return rect.area()*c;
    }
    public static void main(String[] args) {
		 SS rect=new SS(1,2);
		 Cuboid c=new Cuboid();
		 c.rect=rect;
		 c.c=3;
		 System.out.println(c.totaArea());
		 System.out.println(c.volumn());
	}

}

final(最终的)

修饰对象：

变量，方法，类

作用：

修饰变量：只能被赋值一次（赋初值也算一次）
修饰方法：无法被子类重写
修饰类：表示要终止被扩展，类不能被继承（称为：最终类）

this

作用：

形参名称/局部变量名称和成员变量相同时候：
用this（意为：当前对象）指定成员变量
如果不重名，系统自动填写this
用于构造方法的调用
该语句必须是该构造方法的第一条

举例：

public class Sqyare {
	 public Sqyare(int a)
	 {
		 this(a,a);//调用了第二个构造方法
		 a=1;
	 }
	 public Sqyare(int a，int b)
	 {
		 a=10;
		 b=11;
	 }

类和对象的关键字