方法不带'static'关键字，为实例方法，实例方法必须先创建对象，通过“引用.”点方式调用。
注：
·带static的方法为静态方法，通过“类名.”的方式访问，也可以通过“引用.”的方式进行访问，但会出现警告，当对象为null时，并不会出现空指针异常错误，因为并不需要对象的存在；
·类体中定义的变量，为实例变量；方法体内定义的变量为局部变量，在栈内存中存储；
·实例变量存储在堆内存中的对象中；
·堆内存中存储的对象，每当创建一个新对象，即“new”出一个对象时，存储在堆内存中。
代码示例：
package com.beijing.javase.test002;
public class ThisTest {
public static void main(String[] args) {
//调用doSome方法
doSome();
//调用doOther方法
//doOther(); //直接调用doOther方法时，没有对象，编译报错
//需要通过创建对象，进行“引用.”的方式来调用实例方法
ThisTest t = new ThisTest();
t.doOther();
}
public static void doSome() {
System.out.println("do Some");
}
public void doOther() {
System.out.println("do Other");
}
}
就上述代码而言，当调用实例方法时，完整的写法是
this.doOther();
this指的是当前变量，一般情况下是省略的。
this在static方法里时，是不存在的。
那个对象调用构造方法时，this就是谁。
上述直接调用doOther方法时，由于当前方法体内，并没有创建对象，所以编译报错。
由此看来，在static方法中，调用实例方法时，需要创建对象，不能用“this.”的方式来访问。
在静态方法中，无法调用this，因为静态方法的执行，没有对象的参与，是直接采用“类名.”的方式，所以不存在this。
当在类体中定义了一个非static变量时，无法在带有static的方法中直接调用，因为再类体中定义的为实例变量，需要通过“引用.”的方式来调用。即先创建一个对象，来进行引用；实例变量是对象级别的；
代码示例：
package com.beijing.javase.test001;
public class ThisTest {
//类体中定义了一个sum变量
int sum = 10;
public static void main(String[] args) {
//编译报错
//System.out.println(sum);
ThisTest t = new ThisTest();
System.out.println(t.sum);
}
}
最终结论：在带有static的方法当中不能直接访问实例变量和实例方法。因为实例变量和实例方法都需要对象的存在。
而static的方法中是没有this的。也就是说当前对象是不存在的，自然也就无法访问当前对象的实例方法及实例变量。
在构造方法中，通过当前的构造方法调用其他的构造方法【语法格式：this(实参);】
在一个类 文件中，当一个无参构造方法用this调用有参构造方法的时候，this必须在第一行（由此说明，只能有一句）
带有static关键字的变量，为静态变量；在类加载的时候初始化，不需要创建对象来开辟内存；静态变量的内存开辟在方法区内存当中；调用的时候，不需要创建对象，采用“类名.”的方式来调用静态变量。
多个对象具有同一变量的时候，适合创建静态变量，节省内存空间。
当所有对象具有这个属性，但是这个属性根据对象的变化而变化，适合采用实例变量，存储在堆内存创建的对象中。
当所有对象具有这个属性，并且所有的对象具有的这个属性都是相同的，适合采用静态变量，存储在方法区内存中。
所有的静态变量都可以采用“类名.”也可以采用“引用.”的方式，会出现警告，当引用是null时，也不会出现空指针错误，因为是不依赖于对象的。
static修饰的所有元素都是类级别的特征，与具体的对象无关。
static关键字
static静态代码块，在类加载的时候执行，且执行一次；静态代码块可以有多个，按照顺序执行；位于类体中；main方法执行前执行；
代码格式：
static {
java代码
}
实例代码块
也存在于类体中，初始化对象的时候执行，可有多个，按照顺序执行，位于类体中；在new一个对象的时候会执行
public class ThisTest {
//实例代码块
{
java语句
}
public static void main(String[] args) {
}
}
带有static修饰的方法为静态方法，调用静态方法时，采用“类名.”的方式调用；静态方法无妨直接访问实例变量、调用实例方法，需采用“引用.”的方式；
方法描述的是动作，当所有的对象执行这个动作的时候，最终产生影响是一样的，那么这个动作就不属于某一个对象的动作了，可以提升为这个类级别的动作，提供模板级别的动作，个人感觉与静态变量的使用原因相同
在静态方法中，无法调用this，因为静态方法的执行，没有对象的参与，是直接采用“类名.”的方式，所以不存在this。
目前理解的Java代码总结
//此处的“Test”与文件名相同，例如本文件名就为Test.java
public class Test {
静态代码块; //类加载的时候执行
static {
*****;
}
实例代码块; //初始化对象的时候开始执行
{
****;
}
静态变量; //通过“类名.变量名”的方式调用
static int i = 10;
实例变量; //通过“引用.变量名”的方式调用，即先new一个对象，通过“对象.”的方式调用
int j = 20;
构造方法; //也叫构造函数，构造方法分为有参构造和无参构造，默认有一个无参构造，也可以手动创建无参构造方法
//方法名需同类名相同
//无参
public 类名() {
}
//有参
public 类名(int a,String b) {
System.out.println(a,b);
}
静态方法; //通过“类名.方法”调用，当与静态方法处于一个类文件下时，“类名.”可以省略
public static void sum(){
*****;
}
实例方法; //通过“引用.方法”调用，即先new一个对象，通过“对象.”的方式调用
public void sum2(){
*******;
}
例：
public static void main(String[] args){
//调用上文中的静态方法
//完整写法
Test.sum();
//省略写法
sum();
//访问上文中的静态变量
//完整写法
System.out.println(Test.i);
//省略写法，因为处于同一类中，所以“类名.”可以省略
System.out.println(i);
//调用上文中的实例方法，需首先创建对象，通过“引用.”的方式进行访问
Test t = new Test();
t.sum2();
//调用实例变量
System.out.println(t.j);
}
}
例：A类继承B类 public class A extends B
B类为父类、基类、超类、superclass
A类为子类、派生类、subclass
在继承的过程中，私有的不支持继承，构造方法不支持继承，其余的可以继承；继承只能单继承，但是可以间接继承；
当父类中的方法无法满足子类中的使用，需要重写，需要到方法的覆盖；
覆盖的要求：
·方法重写的时候，具有继承关系的父子类之间；
·方法重写的时候，返回值的类型、方法名、形参列表相同；
·方法重写的时候，不能比父类中方法的访问权限低（public > private）；
·方法重写的时候，能抛出的异常不能更多，只能更少；
即满足以上条件时，当子类与父类中具有相同的方法时，执行的是子类当中的方法，因为视于方法被覆盖；
注：
私有方法不被继承，所以不能覆盖；
构造方法不被继承，所以不能覆盖；
静态方法不存在覆盖；
覆盖只针对方法，不谈及属性；
