构造方法只可以在创建对象时调用，用于初始化对象；
在普通成员方法里面不可以this(“张三”);但是可以this.study();
super关键字代表父类对象；
在创建子类对象时，父类的构造方法会先执行，因为子类中所有构造方法的第一行有默认的隐式super();语句；
Super()父类构造方法
Super.study()父类中的study方法
Super.name父类对象中的name属性
在子类的构造方法中第一行默认有一个super()，默认调用父类的空参构造方法；
//不写也有，写也有
Super()必须要写在构造方法第一行；
为什么子类对象创建都要访问父类中的构造方法？因为子类继承了父类的内容，所以创建对象时，必须要先看父类是如何对其内容进行初始化的；
//初始化和清理，这里的作用就是初始化父类对象；
无论到哪儿，子类的构造方法都会有一个super()，用来初始化父类对象，所以在创建类时，务必要提供一个无参构造方法；
//如果父类没有无参构造，只有有参构造，那么super(传入实参);传入实参的super构造器也是可以的；
//只是走一下父类的构造方法；
//对父类的内容初始化；
那么，子类中的构造方法为什么会有一句隐式的super()呢？
原因：子类会继承父类中的内容，所以子类在初始化时，必须先到父类中去执行父类的初始化动作。这样，才可以使用父类中的内容。
当父类中没有空参数构造方法时，子类的构造方法必须有显示的super语句，指定要访问的父类有参数构造方法；
如果子类的构造方法第一行写了this调用了本类其他构造方法，那么super调用父类的语句还有吗？
这时是没有的，因为this()或者super(),只能定义在构造方法的第一行，因为初始化动作要先执行；
this和super关键字在构造方法中，只能在第一行，所以使用了this关键字之后，super就不存在了；
只要子类构造方法能够直接或者间接调用父类构造方法（无餐/有参）即可；
this()和super()只能写在构造方法中，在普通方法不可以有this()和super()，因为这两个是初始化对象的构造方法，只可以在创建对象时使用；在普通方法中使用this和super关键字则没有必须在第一行的要求，只有this()和super()这种形式要求必须在第一行；
父类构造方法中是否有隐式的super呢？
也是有的。记住：只要是构造方法默认第一行都是super();
父类的父类是谁呢？super调用的到底是谁的构造方法呢？
Java体系在设计，定义了一个所有对象的父类Object
类中的构造方法默认第一行都有隐式的super()语句，在访问父类中的空参数构造方法。所以父类的构造方法既可以给自己的对象初始化，也可以给自己的子类对象初始化。
如果默认的隐式super()语句在父类中没有对应的构造方法，那么必须在构造方法中通过this或者super的形式明确要调用的构造方法。
this功能：
① 调用本类的成员变量和成员方法
② 区分成员变量和局部变量同名问题
③ 在构造方法中调用其他构造方法
Final用法：修饰类，类的成员，以及局部变量；不能修饰构造方法！
final修饰类不可以被继承，但是可以继承其他类！
final修饰的方法不可以被子类重写，但父类中没有被final修饰方法，子类重写后可以加final；
final修饰的变量称为常量，这些变量只能赋值一次，而且终身不变；
final修饰局部变量（基本数据类型），一旦赋值终身不变；
//静态常量才会变成蓝色（static final）
final修饰局部变量（引用数据类型），一旦赋值一个地址终身不变；
final修饰成员变量，需要在创建对象前初始化，负责报错；成员变量进堆，会给一个默认值，不手动赋值就没有意义了；要么手动赋值，要么构造方法赋值，只要在创建对象之前赋值就没问题，注意：SET方法是不可以的！！！
package com.oracle.demo04;
public class Person {
//声明了常量之后，要么手动附初值，要么在构造方法中赋值，不可以在SET方法中赋值，因为常量要在创建对象分配地址之前赋值；
final String name;
public Person(String name){
this.name=name;
}
}
package com.oracle.demo01;
public class Student {
private String name;
private static String Schoolname;
public Student(){
super();
}
public Student(String name, String schoolname) {
super();
this.name = name;
Schoolname = schoolname;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSchoolname() {
return Schoolname;
}
public void setSchoolname(String schoolname) {
Schoolname = schoolname;
}
}
package com.oracle.demo01;
public class Test {
public static void main(String[] args) {
Student s1=new Student("小红","清华大学");
Student s2=new Student("小明","清华大学");
Student s3=new Student("小亮","清华大学");
s2.setSchoolname("北京大学");
System.out.println(s1.getSchoolname()+"……"+s2.getSchoolname()+"……"+s3.getSchoolname());
}
}
/*
* 1.加载Test.class和Student.class
*
* 2.加载main方法和private static String Schoolname;进入方法与数据共享区（静态区）
*
* 3.main方法进栈，执行内容
*
* 4.new的对象进堆，由于Schoolname已经进入静态取，所以堆内只有String name
*
* 5.执行对象的构造方法，将小红赋值给堆中的String name，静态区中的Schoolname被赋值成清华大学
*
* 6.几个对象都是这个流程，最后把对象s2的学校改为北京大学，由于所有Student对象都指向这个静态区，所以所有对象都的Schoolname都变为北京大学了
*
* */
被static修饰的成员变量属于类，不属于这个类的某个对象（也就是说，多个对象在访问或修改static修饰的成员变量时，其中一个对象将static成员变量值进行了修改，其他对象中的static成员变量值跟着改变，即多个对象共享同一个static成员变量）；
被static修饰的成员可以并且建议通过类名直接访问；
静态内容是优先于对象存在，只能访问静态，不能使用this/super（本类对象/父类对象）；静态修饰的内容存于静态区；
同一个类中，静态成员只能访问静态成员（因为静态成员是和main方法一起出现的，静态成员出现的时候，普通成员还没出现）；
main方法为静态方法仅仅为程序执行入口，它不属于任何一个对象，可以定义在任意类中；
非静态成员可以访问静态成员，静态成员不可以访问非静态成员；
静态&多态：
package com.oracle.demo02;
public class Fu {
static int i=1;
public static void f(){
System.out.println("这是父类静态方法");
}
}
package com.oracle.demo02;
public class Zi extends Fu{
static int i=2;
public static void f(){
System.out.println("这是子类重写后的方法");
}
}
package com.oracle.demo02;
public class Test {
public static void main(String[] args) {
Fu f=new Zi();
System.out.println(f.i);
f.f();
//多态特殊点：子类对象交给父类引用，此时静态成员变量和静态成员方法，都是调用父类的，因为此时成员变量和成员方法都属于类不属于对象
}
}
使用public static final修饰的变量来定义静态常量；
定义格式：
public static final 数据类型 变量名 = 值;
接口中的每个成员变量都默认使用public static final修饰；
所有接口中的成员变量已是静态常量，由于接口没有构造方法，所以必须显示赋值，可以直接用接口名访问；
//当final修饰的成员变量必须在创建对象之前赋值，要么直接附初值要么用构造方法赋值；
匿名对象是指创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量；
//没有引用；
① 创建匿名对象直接使用，没有引用变量；
new Person().eat()
② 匿名对象在没有指定其引用变量时，只能使用一次；
new Person().eat()和new Person().eat()不是相同的对象；
③ 匿名对象可以作为方法接收的参数，方法返回值使用；（作为实参传入某个方法，或者作为返回值使用）
什么是内部类
将类写在其他类的内部，可以写在其他类的成员位置和局部位置，这时写在其他类内部的类就称为内部类。其他类也称为外部类；
什么时候使用内部类
在描述事物时，若一个事物内部还包含其他可能包含的事物，比如在描述汽车时，汽车中还包含这发动机，这时发动机就可以使用内部类来描述；
① 成员内部类：在成员位置
② 局部内部类：在方法中
内部类的分类：
内部类分为成员内部类与局部内部类。
我们定义内部类时，就是一个正常定义类的过程，同样包含各种修饰符，继承与实现关系等；在内部类中可以直接访问外部类的所有成员；
成员内部类，定义在外部类中的成员位置。与类中的成员变量相似，可通过外部类对象进行访问
定义格式
class 外部类 {
修饰符 class 内部类 {
//其他代码
}
}
访问方式
外部类名.内部类名 变量名 = new 外部类名().new 内部类名();
package com.oracle.demo04;
public class Outer {
int i=0;
//成员内部类
class inner{
int i=2;
public void show(){
int i=1;
//1.成员内部类的成员方法，访问内部类中的成员变量，使用this关键字
//2.成员内部类的成员方法，访问外部类中的成员变量，使用外部类类名.this.成员变量名
Outer.this.show();
System.out.println(Outer.this.i);
}
}
public void show(){
System.out.println("这是外部类成员方法");
}
}
package com.oracle.demo04;
public class Test {
public static void main(String[] args) {
//创建Outer中成员内部类inner的对象，然后调用成员内部类的方法：
Outer.inner inn=new Outer().new inner();
inn.show();
}
}
局部内部类：
局部内部类，定义在外部类方法中的局部位置。与访问方法中的局部变量相似，可通过调用方法进行访问
定义格式
class 外部类 {
修饰符 返回值类型 方法名(参数) {
class 内部类 {
//其他代码
}
}
}
访问方式
在外部类方法中，创建内部类对象，进行访问
package com.oracle.demo05;
public class Outer {
public void show(){
class Inner{
public void show2(){
System.out.println("这是局部内部类的方法");
}
}
//局部内部类只能在创建类的方法内创建对象，然后调用方法，然后早main方法中创建外部类的对象，调用存在局部内部类的外部类的成员方法；
Inner in=new Inner();
in.show2();
}
}
package com.oracle.demo05;
public class Test {
public static void main(String[] args) {
Outer out=new Outer();
out.show();
}
}