JAVA 类相关知识

局部变量和成员变量的不同：
  1、定义的位置不一样
      局部变量：定义在方法内部
      成员变量：在方法外部，直接写在类中
  2、作用范围不一样
      局部变量：只有方法中能使用，除了方法就不能用
      成员变量：整个类都可以用
  3、默认值不一样
      局部变量：无默认值，先赋值在使用
      成员变量：如果没有赋值有默认值
  4、内存的位置不一样
      局部变量：位于栈内存
      成员变量：为于堆内存
  5、生命周期不一样
      局部变量：随着方法的进栈而诞生，随着方法出栈而消失
      成员变量：随着对象的创建而诞生，随着对象被垃圾回收而消失
 
局部变量不能被访问控制修饰符及 static 所修饰；但是，成员变量和局部变量都能被 final 所修饰

构造方法
一个类的构造方法的作用是什么?构造方法是一种特殊的方法，主要作用是完成对象的初始化工作
如果一个类没有声明构造方法，该程序能正确执行吗如果一个类没有声明构造方法，也可以执行！因为一个类即使没有声明构造方法也会有默认的不带参数的构造方法。如果我们自己添加了类的构造方法（无论是否有参），
Java 就不会再添加默认的无参数的构造方法了，这时候，就不能直接 new 一个对象而不传递参数了，所以我们一直在不知不觉地使用构造方法，这也是为什么我们在创建对象的时候后面要加一个括号（
因为要调用无参的构造方法）。如果我们重载了有参的构造方法，记得都要把无参的构造方法也写出来（无论是否用到），因为这可以帮助我们在创建对象的时候少踩坑
构造方法特点如下：
名字与类名相同。
没有返回值，但不能用 void 声明构造函数。
生成类的对象时自动执行，无需调用。
构造方法不能被 override（重写）,但是可以 overload（重载）,所以你可以看到一个类中有多个构造函数的情况
this super
this   可以理解为：指向对象本身的一个指针
1、当成员变量和局部变量重名时，在方法中使用this时，表示的是该方法所在类中的成员变量。（this是当前对象自己）
 

public class Hello {

    String s = "Hello";

    public Hello(String s) {

       System.out.println("s = " + s);

       System.out.println("1 -> this.s = " + this.s);      

       this.s = s;//把参数值赋给成员变量，成员变量的值改变

       System.out.println("2 -> this.s = " + this.s);

    }

    public static void main(String[] args) {

       Hello x = new Hello("HelloWorld!");

       System.out.println("s=" + x.s);//验证成员变量值的改变    }

}
s = HelloWorld!

1 -> this.s = Hello

2 -> this.s = HelloWorld!

s=HelloWorld!
2 .把自己当作参数传递时，也可以用this.(this作当前参数进行传递)

class A {

    public A() {

       new B(this).print();// 调用B的方法

    }

    public void print() {

       System.out.println("HelloAA from A!");

    }

}

class B {

    A a;

    public B(A a) {

       this.a = a;

    }

    public void print() {

       a.print();//调用A的方法

       System.out.println("HelloAB from B!");

    }

}
3. 我们会用到一些内部类和匿名类，如事件处理。当在匿名类中用this时，这个this则指的是匿名类或内部类本身。这时如果我们要使用外部类的方法和变量的话，则应该加上外部类的类名。

public class HelloB {

    int i = 1;

  

    public HelloB() {

       Thread thread = new Thread() {

           public void run() {

              for (int j=0;j<20;j++) {

                  HelloB.this.run();//调用外部类的方法

                  try {

                     sleep(1000);

                  } catch (InterruptedException ie) {

                  }

              }

           }

       }; // 注意这里有分号

       thread.start();

    }

  

    public void run() {

       System.out.println("i = " + i);

       i++;

    }

    

    public static void main(String[] args) throws Exception {

       new HelloB();

    }

}
4. 在构造函数中，通过this可以调用同一类中别的构造函数
值得注意的是：
　　1：在构造调用另一个构造函数，调用动作必须置于最起始的位置。
　　2：不能在构造函数以外的任何函数内调用构造函数。
　　3：在一个构造函数内只能调用一个构造函数。

public class ThisTest {

    private int age;

    private String str;

  

    ThisTest(String str) {

       this.str=str;

       System.out.println(str);

    }

    ThisTest(String str,int age) {

       this(str);

       this.age=age;

       System.out.println(age);

    }

  

    public static void main(String[] args) {

       ThisTest thistest = new ThisTest("this测试成功",25);

       

    }
this测试成功
25
5. this同时传递多个参数。

public class TestClass {
int x;
int y;

static void showtest(TestClass tc) {//实例化对象
System.out.println(tc.x + " " + tc.y);
}
void seeit() {
showtest(this);
}

public static void main(String[] args) {
TestClass p = new TestClass();
p.x = 9;
p.y = 10;
p.seeit();
}
}
9
10
showtest(this),这里的this就是把当前实例化的p传给了showtest（）
 super
参考链接  ：https://www.cnblogs.com/hasse/p/5023392.html
可以理解为是指向自己超（父）类对象的一个指针

class Country {
    String name;

    void value() {
        name = "China";
    }
}

class Main extends Country {
    String name;

    void value() {
        name = "Shanghai";
        super.value(); // 调用父类的方法
        System.out.println(name);
        System.out.println(super.name);
    }

    public static void main(String[] args) {
        Main c = new Main();
        c.value();
    }
}
Shanghai
China
这里既调用了父类的方法，也调用了父类的变量。若不调用父类方法value()，只调用父类变量name的话，则父类name值为默认值null。
this super 引用构造函数
super（参数）：调用父类中的某一个构造函数（应该为构造函数中的第一条语句）。
this（参数）：调用本类中另一种形式的构造函数（应该为构造函数中的第一条语句）。
this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，
就失去了语句的意义，编译器也不会通过。

class Person { 
    public static void prt(String s) { 
       System.out.println(s); 
    } 
   
    Person() { 
       prt("父类·无参数构造方法： "+"A Person."); 
    }//构造方法(1) 
    
    Person(String name) { 
       prt("父类·含一个参数的构造方法： "+"A person's name is " + name); 
    }//构造方法(2) 
} 
    
public class Chinese extends Person { 
    Chinese() { 
       super(); // 调用父类构造方法（1） 
       prt("子类·调用父类”无参数构造方法“： "+"A chinese coder."); 
    } 
    
    Chinese(String name) { 
       super(name);// 调用父类具有相同形参的构造方法（2） 
       prt("子类·调用父类”含一个参数的构造方法“： "+"his name is " + name); 
    } 
    
    Chinese(String name, int age) { 
       this(name);// 调用具有相同形参的构造方法（3） 
       prt("子类：调用子类具有相同形参的构造方法：his age is " + age); 
    } 
    
    public static void main(String[] args) { 
       Chinese cn = new Chinese(); 
       cn = new Chinese("codersai"); 
       cn = new Chinese("codersai", 18); 
    } 
}
父类·无参数构造方法： A Person.
子类·调用父类”无参数构造方法“： A chinese coder.
父类·含一个参数的构造方法： A person's name is codersai
子类·调用父类”含一个参数的构造方法“： his name is codersai
父类·含一个参数的构造方法： A person's name is codersai
子类·调用父类”含一个参数的构造方法“： his name is codersai
子类：调用子类具有相同形参的构造方法：his age is 18
简述Java中Class对象
java中对象可以分为实例对象和Class对象，每一个类都有一个Class对象，其包含了与该类有关的信息。
获取Class对象的方法：
Class.forName(“类的全限定名”)
实例对象.getClass()
类名.class