1、访问修饰符
1、private
可以修饰变量，方法，不能修饰类 只能访问本类
默认 没有修饰的 可以修饰变量、方法、类 同一个包内可以访问
2、protected
可以修饰变量，方法 可以访问同一个包，继承关系的不同包
3、public
可以修饰类，变量，方法 可以访问任何地方
2、方法重写
继承关系
父类和子类 方法名相同
参数列表相同
方法的返回类型相同（如果是继承关系，子类的方法类型<=父类）
class D1{public Demo1 f() {return null;}
}
class D2 extends D1{public Demo1 f() {return null;}
}
子类方法的访问修饰符>=父类
异常：子类方法的异常（非运行时异常）<=父类
为什么要进行重写？ 扩展父类方法的功能（私有方法不能被重写）
3、继承关系中构造方法的调用规则
（1）子类创建对象时，总是默认调用父类无参的构造方法
（2）如果父类没有无参的构造方法，使用super（）调用指定的构造方法
class A{int x;int y;public A(int x,int y){--------("A");}} class B extends A{public B(int x,int y){super（x,y）;----------（“B”）;}}B b=new B(1,2）；
子类没有super找父类无参构造方法
4、多态
定义：一种类型的变量可以指向不同的对象
Animal a1=new Dog（）;
Animal a2=new Bird（）；
编译时的多态：方法的重载
class A{void f（）{---------------（“f”）； }void f（int x）{---------------（“f”+x）；}}
A a1=new A();
A a2=new A()；a1.f();
a2.f(1);
运行时的多态：方法的重写
在Annimal类中定义eat Dog和Bird类重写了此方法
Animal a1=new Dog（）; 除重写外，其他都是父类
Animal a2=new Bird（）；a1.eat();
a2.eat();
在编译时，看变量的声明类型
运行时，如果子类重写了父类的方法，动态绑定到子类上，运行子类的方法（没有动态绑定方法）
5、多态的应用
方法的参数定义为父类或者接口类型
对象造型：（对象强制转换）
通过instanceof进行对象的判断
instanceof 严格来说是Java中的一个双目运算符，用来测试一个对象是否为一个类的实例
public class Feeder {public void feed(Animal animal) {animal.eat();}//如果animal->dog 调用d（）//如果animal->bird 调用b（）public void test(Animal animal) {if(animal instanceof Dog) {((Dog)animal).d();}if(animal instanceof Bird) {((Bird)animal).b();}}public void test2() {Dog dog=new Dog();Bird bird=new Bird();//bird=(Bird)dog2; //error 兄弟类不能强制转换Animal dog2=new Dog();bird=(Bird)dog2; //运行时异常}public static void main(String[] args) {new Feeder().test2();}}
1、static
修饰变量，方法，静态块
变量：成员变量->类变量（静态变量） 由static修饰的成员变量
实例变量：没有static修饰
局部变量
类变量和实例变量的区别：
类变量对所有对象共享，公佣
实例变量是归对象所有，不是公用的
静态变量可以由类名调用
静态变量：类加载器加载类的时候初始化的
变量的初始化过程:
static int x=5；
int x=16；
修饰方法：
静态方法：由static修饰
实例方法：没有static修饰
int x=1；
static int y=2； void f（）{
}
static void f2（）{
}void test1（）{x=2；//oky=3；f（）； //okf2（）；}static void test2（）{x=2； //erry=3；f（）；//err 静态成员的初始化要先于实例成员，方法需要先创建对象，非静态的可以直接使用静态的，静态的不可以直接使用非静态的f2（）；
}
静态方法是否可以重写？ no，静态方法与对象无关
重载？ yes，
继承？ yes
构造方法是否可以定义静态的？ no 构造方法是创建对象用的
静态方法是否可以使用this，super ？ no
静态块
static{
}
写到类体中，在类加载时，执行一次
public class Hello{static{system.out.println("hello");
}
public static void main(String[] args){
}
}
静态块和构造块
父类的静态块，子类的静态块，父类的构造块，父类的构造方法，子类的构造块，子类的构造方法
class A{static {System.out.println("1");}{System.out.println("2");}public A() {System.out.println("3");}
}
class B extends A{static {System.out.println("A");}{System.out.println("B");}public B() {System.out.println("C");}
}
public class Test2 {public static void main(String[] args) {new B();}}
写到类体中
2、final
fimal 可以修饰类，方法，变量
final可以修饰变量的特点：常量
常量名：一般名字的所有字母都大写，如果有多个单词组成，单词之间用下划线
格式：final int PRUCE=10；
特点：不能改
final修饰的方法：不能重写，保证其唯一性
final修饰类：不能被继承
3、abstract
（1）抽象方法：由abstract修饰的方法
（2）特点：没有方法体
（3）抽象类：由abstract修饰的类 ------ 模块
（4）特点：不能创建对象
（5）抽象类中可以没有抽象方法
（6）抽象类由子类创建对象
（7）子类可以创建对象，实现所有的抽象方法，
没有实现全部的抽象方法，当前类声明为抽象类
4、interface
（1）定义接口
interface 接口名{
变量：int x = 10; public static final修饰的
方法：jdk1.8之前,抽象方法，可以省略abstract，
默认的访问修饰符public
void f();
}
（2）使用接口 implements
实现接口的类，要实现接口中的所有方法，才可以创建对象
如果不实现接口中的所有方法，当前类必须为abstract的类
（3）接口和接口之间是继承关系
interface A{}
interface B extends A{}
interface C{}
（4）类和接口之间是实现，可以实现多个接口
class Demo extends Object1 implmenents B,C{}