（1）类的访问修饰符
public修饰符：公有访问级别
默认修饰符：包级私有访问级别
（2）类成员的访问修饰
| 同一个类中 | 同一个包中 | 子类中 | 任何地方 | |
| private | 可以 | 不可以 | 不可以 | 不可以 |
| 默认修饰符 | 可以 | 可以 | 不可以 | 不可以 |
| protected | 可以 | 可以 | 可以 | 不可以 |
| public | 可以 | 可以 | 可以 | 可以 |
（3）static修饰符
static可以用来修饰
1）成员变量
静态变量，可以直接通过类名访问
2）成员方法
静态方法，可以直接通过类名访问
3）代码块
静态代码块，当Java虚拟机加载类时，就会执行该代码块
（4）static代码块
JVM加载类时，加载静态代码块
1）如果有多个静态块，按顺序加载
2）每个静态代码块只会被执行一次
（5）static变量
类的成员变量包括
1）类变量（静态变量）
a.被static修饰的变量
b.内存中只有一个拷贝
c.类内部，可在任何方法内直接访问静态变量
d.其他类中，可以直接通过类名访问
2）实例变量
a.没有被static修饰的变量
b.每创建一个实例，就会为实例变量分配一次内存，实例变量可以在c.内存中有多个拷贝，互不影响
（6）static变量的作用
1）能被类的所有实例共享，可作为实例之间进行交流的共享数据
2）如果类的所有实例都包含一个相同的常量属性，可把这个属性定义为静态常量类型，从而节省内存空间
（7）static方法
1）静态方法：可直接通过类名访问
a.静态方法中不能使用this和super
b.不能直接访问所属类的实例变量和实例方法
c.可直接访问类的静态变量和静态方法
d.静态方法必须被实现（main()就是最常用的静态方法）
2）实例方法：通过实例访问
可直接访问所属类的静态变量、静态方法、实例变量和实例方法
（8）举例
Demo01类：
public class Demo01 {
//声明static修饰的变量
static int num1 = 100;
static int num2 = 1000;
static final int STUDENT_NUM = 1000;
final static double PI = 3.14;
int num3 = 500;
//写两个static修饰的方法
public static void test(){
System.out.println("我是static修饰的test()方法");
num1 =200;
}
public static void ceShi(){
System.out.println("我是static修饰的ceShi()方法");
test();
//demo();
}
public void demo(){
System.out.println("我是没有static修饰的普通demo()方法");
ceShi();
}
//写两个静态代码块
static{
System.out.println("我是第2个static代码块");
}
static{
System.out.println("我是第1个static代码块");
}
}
Demo01Test类：
public class Demo01Test {
public static void main(String[] args) {
// 创建Demo01类对象
Demo01 d1 = new Demo01();
d1.num1 = 1000;
System.out.println(d1.num1);//1000
d1.num3 = 5000;
System.out.println(d1.num3);
Demo01 d2= new Demo01();
System.out.println(d2.num1);//1000
System.out.println(d2.num3);
}
}
StaticTest类：
public class StaticTest {
static int num;
public static void main(String[] args) {
num++;
StaticTest st1 = new StaticTest();
st1.num++;
StaticTest st2 = new StaticTest();
st2.num++;
StaticTest.num++;
System.out.println(num);
}
}
2、继承
（1）概念：继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。
（2）使用继承
1）编写父类
[访问修饰符] class 父类名 {
//公共的属性和方法
}
2）编写子类，继承父类
[访问修饰符] class 子类名 extends 父类名 {
//子类特有的属性和方法
}
注：继承是Java中实现代码重用的重要手段之一。Java中只支持单根继承，即一个类只能有一个直接父类
（3）子类访问父类成员
访问父类构造方法
super();
super(参数);
访问父类属性
super.属性名;
访问父类方法
super.方法名;
（4）super的使用
1）使用super关键字,super代表父类对象
2）super只能出现在子类的方法和构造方法中
3）在子类构造方法中调用且必须是第一句
4）不可以访问父类中定义为private的属性和方法
（5）继承条件下构造方法的调用规则
1）子类构造方法没有通过super显式调用父类的有参构造方法，也没通过this显式调用自身其他构造方法
（系统默认调用父类的无参构造方法）
2）子类构造方法通过super显式调用父类的有参构造方法
（执行父类相应构造方法，而不执行父类无参构造方法）
3）子类构造方法通过this显式调用自身的其他构造方法，在相应构造方法中应用以上两条规则
（6）子类继承父类的什么
1）继承public和protected修饰的属性和方法，不管子类和父类是否在同一个包里
2）继承默认权限修饰符修饰的属性和方法，但子类和父类必须在同一个包里
（7）不能被继承的父类成员
1）private成员
2）子类与父类不在同包，使用默认访问权限的成员
3）构造方法
（8）使用继承条件
符合is-a关系的设计使用继承
（9）访问修饰符protected
1）可以修饰属性和方法
2）本类、同包、子类可以访问
（10）举例
GrandFathe类：
public class GrandFather {
private double money;
public GrandFather() {
super();//调用父类Object类里的无参构造方法
}
public GrandFather(double money) {
super();//调用父类Object类里的无参构造方法
this.money = money;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
//定义一个普通方法
public void print(){
System.out.println("我是GrandFather类里的print()方法");
}
}
Father类：
public class Father extends GrandFather {
private String antique;
public Father() {
super();// 调用父类GrandFather类里的无参构造方法
}
public Father(double money, String antique) {
super(money);// 调用父类GrandFather类里的有参构造方法
this.antique = antique;
}
public String getAntique() {
return antique;
}
public void setAntique(String antique) {
this.antique = antique;
}
public void test(){
System.out.println("我是Father类里的test()方法");
}
}
GanDie类：
public class GanDie {
private String word;
public GanDie() {
super();// 调用父类Object类里的无参构造方法
}
public GanDie(String word) {
super();// 调用父类Object类里的无参构造方法
this.word = word;
}
public String getWord() {
return word;
}
public void setWord(String word) {
this.word = word;
}
}
Son类：
public class Son extends Father {
private String hobby;
public Son() {
super();// 调用父类Father类里的无参构造方法
}
public Son(double money, String antique, String hobby) {
super(money, antique);// 调用父类Father类里的有参构造方法
this.hobby = hobby;
}
public String getHobby() {
return hobby;
}
public void setHobby(String hobby) {
this.hobby = hobby;
}
public void demo(){
System.out.println("我是Father类里的demo()方法");
}
}
Test类：
public class Test {
public static void main(String[] args) {
Son son1 = new Son();
son1.setHobby("买跑车");//调用Son类里的setXxx()方法
son1.setAntique("蒙娜丽莎");//调用Father类里的setXXX()方法
son1.setMoney(10000000);//调用GrandFather类里的setXxx()方法
son1.print();
son1.test();
son1.demo();
}
}
