B.java
public class B {
public static void test() {
System.out.println("我是B，我是父类！");
}
}
A.java
public class A extends B{
public static void test() {
System.out.println("我是A，我是子类！");
}
}
Main.java
public class Main {
public static void main(String[] args) {
A a=new A();
a.test();
B b=new A();//上转型对象
b.test();
//如果子类重写了父类的静态方法，那么子类对象的上转型对象不能调用子类的静态方法，只能调用父类的静态方法
//父类的static方法是不会被重写的,不具有多态特性，即使子类中有相同的static方法，编译能通过，但不会覆盖父类的static方法。
//静态方法的调用只和左边定义的数据类型有关
}
}
---静态执行结果------ -----非静态执行结果-（分别去掉A、B两类方法中的static）----
我是A，我是子类！ 我是A，我是子类！
我是B，我是父类！ 我是A，我是子类！
非静态的方法才能重写（覆盖）
上转型对象可以访问子类继承或隐藏的成员变量，可以操作子类继承或重写的方法，其作用等价于子类对象去调用这些方法，因此，如果子类重写了父类的某个方法，则当对象的上转型对象调用这个方法时一定是调用了这个重写的方法
上转型对象可以被强制转换到它的子类对象，这时，该子类对象又具备了子类的所有属性和功能
上转型对象不能操作子类新增的成员变量和方法
对象的上转型对象：继承或隐藏的变量；继承或重写的方法；
对象：子类新增的变量和方法；继承或隐藏的变量；继承或重写的方法；
以上也可以概括为：对象能执行那些方法，主要看左边的类中有没有，和右边new的类型关系不大
子类只能重写父类非私有的方法
重写需要有继承关系，子类重写父类的方法，方法名和参数列表必须相同。重写的方法范围可以扩大，但不能缩小。重写抛出的异常只能缩小，不能扩大
为什么需要重写：父类的功能子类不一定需要或者不一定满足
static方法不能重写，因为它是属于类（当类加载时，static方法就已经存在，而此时对象还未创建），而不属于实例对象；final修饰的方法在常量池中，无法重写；private方法无法重写
String name=new String();
Object nam=new String();//Java中的类全部默认继承Object类;父类的引用指向子类对象
Father father=new Son(); //上转型对象实例是子类对象
多态存在的条件：有继承关系；子类重写父类方法；父类引用指向子类对象；
instanceof 运算符是二目运算符，X（对象） instanceof Y（类）：当X是Y本类或者子类创建的对象时，true；先有继承关系，再有instanceof的使用
X（对象） instanceof Y（类）//编译时看左边类型，运行时看右边对象；X和Y比较之前会先判断X的左边类型能不能转换成Y类型，能则通过，
//不能则编译报错
public class staticBlock {
// 2 赋初值
{
System.out.println("我是匿名代码块");
}
// 1 只执行一次
static {
System.out.println("我是静态代码块");
}
// 3
public staticBlock() {
System.out.println("我是构造方法");
}
public static void main(String[] args) {
staticBlock s1=new staticBlock();
System.out.println("===================");
staticBlock s2=new staticBlock();
}
}
------执行结果-------
我是静态代码块
我是匿名代码块
我是构造方法
===================
我是匿名代码块
我是构造方法
例如public 类名(){}
int i=10; String s=“ChenShuBo”;1、成员内部类：成员内部类利用已经实例化的外部类进行内部类的实例化，内部类可以调用外部类的私有属性和私有方法
Application.java
public class Application {
public static void main(String[] args) {
Outer outer = new Outer();//实例化外部类
Outer.Inner inner = outer.new Inner();//实例化内部类
inner.getID();
inner.inner();
}
}
Outer.java
public class Outer {
private int id=10;
public void outer(){
System.out.println("这是外部类！");
}
public class Inner{
public void inner(){
System.out.println("这是内部类！");
}
public void getID(){
System.out.println(id);
outer();
}
}
}
------执行结果------
10
这是外部类！
这是内部类！
2、使用static修饰成员内部类就成了静态内部类；static只能修饰内部类不能修饰普通类
3、 定义在普通类（没有main方法）中的方法中的类称为局部内部类
4、
Application.java
public class Application {
public static void main(String[] args) {
new Apple().run //匿名内部类
new user(){ //匿名内部类
@Override
public void run() {}
};
}
}
user.java
interface user{
void run ();
}
Apple.java
class Apple{
void run(){ }
}
原文：https://www.cnblogs.com/chenshubo/p/14874723.html