Java中的关键字
this关键字
this对象指向对象本身，一个类可以通过this来获得一个来代表它自身的对象变量。this通常由3种使用情况：
1.调用实例变量
指的是访问类中的成员变量，用来区分成员变量和局部变量（重名问题）
2.调用实例方法
用来访问本类的成员方法
this.();
1.访问本类的构造方法
2.()中可以有参数的 如果有参数 就是调用指定的有参构造
注意点：
this()不能用在普通方法当中，只能用在构造方法里面
this()必须是构造方法里面的第一句
3.调用其他构造方法
在构造方法重载时，一个构造方法可以调用其他的构造方法
public class Person {
// 名字
private String name;
// 年龄
private int age;
// 出生日期
private Date birthDate;
// 三个参数构造方法
public Person(String name, int age, Date d){ ①
this.name = name; ②
this.age = age; ③
birthDate = d;
System.out.println(this.toString()); ④
}
public Person(String name, int age) {
// 调用三个参数构造方法
this(name, age, null); ⑤
}
public Person(String name, Date d) {
// 调用三个参数构造方法
this(name, 30, d); ⑥
}
public Person(String name) {
// System.out.println(this.toString());
// 调用Person(String name, Date d)构造方法
this(name, null); ⑦
}
}
代码第①行声明三个参数构造方法，其中参数
name和age与实例变量name和age命名冲突，参数是作用域为整个方法的局部变量，为了防止局部变量
与成员变量命名发生冲突，可以使用this调用成员变量，见代码第②行和第③行。
this也可以调用本对象的方法，见代码第④行的this.toString()语句，在本例中this可以省略。
在多个构造方法重载时，一个构造方法可以调用其他的构造方法，这样可以减少代码量，上述代码第
⑤行this(name, age, null)使用this调用其他构造方法。类似调用还有代码第⑥行的this(name, 30, d)和第⑦
行的this(name, null)。
super关键字
java中的super关键字是一个引用变量，用于引用父类对象。关键字“super”以继承的概念出现在类中。主要用于以下情况：
1.使用super变量
// Base class vehicle
class Vehicle{
int maxSpeed = 120;
}
// Car extending vehicle
class Car extends Vehicle{
int maxSpeed = 180;
void display()
{
System.out.println("Maximum Speed: " + super.maxSpeed);
//这边注意，变量是super.maxSpeed
}
}
class Test
{
public static void main(String[] args)
{
Car small = new Car();
small.display();
}
}
输出的结果是：
Maximum Speed: 120
这里可以看出，super调用的父类的变量
###2.使用super方法：
当我们要调用父类方法时使用,父类和子类都具有相同的命名方法，那么为了解决歧义，我们使用super关键字。这段代码有助于理解super关键字的使用情况。
class Person
{
Person()
{
System.out.println("Person class Constructor");
}
}
/* subclass Student extending the Person class */
class Student extends Person
{
Student()
{
super();
System.out.println("Student class Constructor");
}
}
class Test
{
public static void main(String[] args)``
{
Student s = new Student();
}
}
输出结果：
Person class Constructor
Student class Constructor
可以看出，在子类的方法中，使用super之后，就会调用父类中同名的方法
注意：
这里的super语句，必须位于第一句，当同时出现this和super时，super语句放在第一位
3.使用超级构造函数：
super关键字也可以用来访问父类的构造函数。更重要的是，'超’可以根据情况调用参数和非参数构造函数。以下是解释上述概念的代码片段
class Person
{
Person(){
System.out.println("Person class Constructor");
}
}
class Student extends Person{
Student()
{
super();
System.out.println("Student class Constructor");
}
}
class Test
{
public static void main(String[] args)
{
Student s = new Student();
}
}
输出结果：
Person class Constructor
Student class Constructor
static关键字
1.static修饰类
普通类是不允许声明为静态的，只有内部类才可以
public class Statictest{
//static关键字修饰内部类
public static class InnerClass{
InnerClass(){
System.out.println("=====静态内部类=====");
}
public void InnerMethod(){
System.out.println("=====静态内部方法=====");
}
}
public static void main(String[] args){
//直接通过statictest类名访问静态内部类InnerClass
InnerClass inner=new StaticTest.InnerClass();
//静态内部类可以跟普通类一样使用
inner.InnerMethod();
}
}
输出结果：
=====静态内部类=====
=====静态内部方法=====
如果没有用static修饰InterClass，则只能new 一个外部类实例。再通过外部实例创建内部类。
2.static修饰方法
修饰方法时，与类相同，可以直接通过类名来调用
public class StaticMethod{
//static关键字修饰内部类
public static void test(){
System.out.println("=====静态方法=====");
}
public static void main(String[] args){
//方法一，直接通过类名访问方法
StaticMethod.test()
//方法二，实例化一个对象
StaticMethod fdd=new StaticMethod();
fdd.test();
}
}
3. static修饰变量
被static修饰的成员变量叫做静态变量，也叫做类变量，说明这个变量是属于这个类的，而不是属于是对象，没有被static修饰的成员变量叫做实例变量，说明这个变量是属于某个具体的对象的。
public class StaticVar{
private static String name="静态变量";
public static void main(String[] args){
//直接通过类名访问
StaticVar.name
}
}
4.static修饰代码块
如果初始化静态变量不是简单常量，需要进行计算才能初始化，可以使用静态（static）代码块，静态
代码块在类第一次加载时执行，并只执行一次
public class Account {
// 实例变量账户金额
double amount = 0.0;
// 实例变量账户名
String owner;
// 静态变量利率
static double interestRate;
// 静态方法
public static double interestBy(double amt) {
// 静态方法可以访问静态变量和其他静态方法
return interestRate * amt;
}
// 静态代码块
static {
System.out.println("静态代码块被调用...");
// 初始化静态变量
interestRate = 0.0668;
}
}
final关键字
1.final修饰变量
final修饰的变量即成为常量，只能赋值一次，但是final所修饰局部变量和成员变量有所不同。
注意点：
- final修饰的局部变量必须使用之前被赋值一次才能使用。
- final修饰的成员变量在声明时没有赋值的叫“空白final变量”。空白final变量必须在构造方法或静态代码块中初始化。
2.final修饰类
final修饰的类不能被继承。
final class SuperClass {
}
class SubClass extends SuperClass { //编译错误
}
编译时会出错，因为类SuperClass不允许继承
3.final修饰方法
final修饰的方法不能被子类覆盖。
class SuperClass {
final void doSomething() {
System.out.println("in SuperClass.doSomething()");
}
}
class SubClass extends SuperClass {
@Override
void doSomething() { //编译错误
System.out.println("in SubClass.doSomething()");
}
}
子类中的void doSomething()方法试图覆盖父类中void doSomething()方法，父类中的void doSomething()
方法是final的，因此会发生编译错误。
pdf和md文件下载链接: //download.csdn.net/download/weixin_43308622/12102217.
