免费行情软件网站下载无病毒百度推广渠道户
目录
static关键字
（1）static修饰成员变量
（2）static修饰成员方法
super和this关键字
super关键字
示例1：使用super调用父类的构造器
示例2：使用super访问父类的方法
示例3：使用super访问父类的变量
示例4：super在方法重写中的使用
使用super时的注意事项
父类构造与子类构造的执行顺序
情况一：父类是有参构造时
情况二：父类是显示定义无参构造，或默认无参构造时，子类的构造中第一行会默认有一个super()
this关键字
1. 区分实例变量和局部变量
2. 在构造方法中调用另一个构造方法
3. 返回当前对象的引用
4. 在内部类中引用外部类对象
总结
访问限定符
1.public
2.protected
3.默认（无修饰符）：
4.private：
static关键字
（1）static修饰成员变量
static修饰的成员变量，赋值一次，以后这个类实例化出的其它对象初始都是这个值
访问形式：
1.类名.成员变量
2.对象引用.成员变量
但是通过类名去访问成员变量更好，因为这个成员变量属于类。
静态的成员不依赖对象，意味着不需要对象的引用来调用。
静态成员变量的特性：
1.不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中
2.既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问
3.类变量存储在方法区当中
4. 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)
而静态的变量属于类变量，随着类的加载而被创建，而局部变量是调用该方法的时候，才创建的。
所以，此时两种变量的性质是冲突的。Java当中不允许定义局部的静态变量。
（2）static修饰成员方法
static修饰的方法为静态方法
在静态方法中不能够直接调用非静态方法，因为静态方法不依赖于对象，可以直接通过类名进行访问，而非静态方法依赖对象，需要通过对象的引用访问。
但是在静态方法中可以通过对象的引用调用非静态方法
在staic方法当中不能使用this关键字，因为static不依赖对象
super和this关键字
super关键字
在Java中，super关键字用于访问父类（超类）的成员变量、方法和构造器
示例1：使用super调用父类的构造器
class Animal {String name;public Animal(String name) {this.name = name;System.out.println("Animal constructor called. Name: " + name);}
}class Dog extends Animal {String breed;public Dog(String name, String breed) {super(name); // 调用父类的构造器this.breed = breed;System.out.println("Dog constructor called. Breed: " + breed);}
}public class SuperExample {public static void main(String[] args) {Dog dog = new Dog("Buddy", "Labrador");}
}输出：
Animal constructor called. Name: Buddy
Dog constructor called. Breed: Labrador示例2：使用super访问父类的方法
class Vehicle {void start() {System.out.println("Vehicle started");}
}class Car extends Vehicle {void start() {super.start(); // 调用父类的方法System.out.println("Car started");}
}public class SuperExample2 {public static void main(String[] args) {Car car = new Car();car.start();}
}输出：
Vehicle started
Car started 示例3：使用super访问父类的变量
class Parent {int value = 10;
}class Child extends Parent {int value = 20;void display() {System.out.println("Child value: " + value); // 访问子类的变量System.out.println("Parent value: " + super.value); // 使用super访问父类的变量}
}public class SuperExample3 {public static void main(String[] args) {Child child = new Child();child.display();}
}输出：
Child value: 20
Parent value: 10示例4：super在方法重写中的使用
class Parent {void display() {System.out.println("Parent display method");}
}class Child extends Parent {@Overridevoid display() {super.display(); // 调用父类的被重写方法System.out.println("Child display method");}
}public class SuperExample4 {public static void main(String[] args) {Child child = new Child();child.display();}
}输出：
Parent display method
Child display method使用super时的注意事项
（1）super只能访问当前类的父类，不能访问父类的父类
（2）父类有构造方法的时候，子类也必须创建构造方法
当父类有构造方法的时候，子类也必须创建构造方法，并且用super调用父类构造方法，为父类的构造方法进行初始化。
一、父类有有参构造方法：
如果父类构造方法是一个有参的构造：
那么子类也必须创建构造方法为父类的构造方法进行初始化：
两种方式对父类进行初始化
二、父类是默认的无参构造时：
如果没有自己手动写构造方法时，java中会提供空的构造方法
此时子类会默认也有一个空的构造并且子类的构造第一行使用super调用父类的构造
三、父类是显示定义的无参构造：
比如下面的这种情况：
子类可以不写构造方法，java会提供空的构造方法
此时的输出结果为：
BaseBase父类构造与子类构造的执行顺序
父子父子，先有父再有子。
即子类对象构造时，需要先调用基类构造方法，然后执行子类的构造方法
因为super（）必须在子类构造方法的第一行
情况一：父类是有参构造时
执行结果：
情况二：父类是显示定义无参构造，或默认无参构造时，子类的构造中第一行会默认有一个super()
执行结果：
父类无参构造
子类的无参构造this关键字
在Java中，this关键字是一个非常重要的引用变量，它指代当前对象。
下面讲一讲它的主要用途：
1. 区分实例变量和局部变量
当方法的参数名称与类的成员变量名称相同时，可以使用this关键字来区分成员变量和局部变量。
public class Person {private String name;public Person(String name) {this.name = name; // this.name指的是类的成员变量name，而右侧的name是构造方法的参数}public void setName(String name) {this.name = name; // 同样，这里使用this来区分成员变量name和参数name}public String getName() {return name;}
}
2. 在构造方法中调用另一个构造方法
一个类的构造方法可以通过this()调用同一个类的另一个构造方法。注意，这样的调用必须是构造方法中的第一条语句。
public class Rectangle {private int width;private int height;// 参数化构造方法public Rectangle(int width, int height) {this.width = width;this.height = height;}// 使用this调用另一个构造方法public Rectangle(int size) {this(size, size); // 调用有两个参数的构造方法}
}
3. 返回当前对象的引用
在链式调用中，this可以用来返回当前对象的引用。
public class StringBuilderExample {private String text = "";public StringBuilderExample append(String str) {this.text += str;return this; // 返回当前对象的引用，允许链式调用}public String toString() {return this.text;}public static void main(String[] args) {StringBuilderExample example = new StringBuilderExample();System.out.println(example.append("Hello").append(", ").append("World!"));}
}
4. 在内部类中引用外部类对象
在内部类（如匿名内部类或非静态内部类）中，this通常指向内部类对象本身。如果要从内部类访问外部类对象，可以使用外部类名.this。
public class OuterClass {private String message = "Hello from OuterClass!";class InnerClass {void display() {System.out.println(OuterClass.this.message); // 使用OuterClass.this访问外部类的成员变量}}public static void main(String[] args) {OuterClass outer = new OuterClass();OuterClass.InnerClass inner = outer.new InnerClass();inner.display();}
}
总结
this关键字在Java中是一个非常有用的特性，它提供了对当前对象的引用，有助于解决命名冲突、实现构造方法之间的调用、支持链式方法调用以及在内部类中访问外部类对象。
访问限定符
在Java中，访问限定符（也称为访问修饰符）如
public、protected、private以及默认（不写任何关键字，也称为包访问权限）也属于关键字的一部分。
在Java中，访问限定符用于控制类、方法、变量等成员的访问权限。Java提供了四种主要的访问限定符：public、protected、默认（不写任何关键字）和private。
1.public
- 可以被任何其他类访问。
- 如果一个类被声明为
public，那么它必须被定义在一个文件中，且文件名必须与类名相同（包括大小写）。 - 常用于需要被其他任何类访问的类、方法或变量。
2.protected
- 可以被同一个包内的其他类访问。
- 还可以被不同包中的子类访问。
- 常用于需要被同一个包内的其他类访问，同时也希望被其他包中的子类继承并重写的类、方法或变量。
3.默认（无修饰符）
- 也称为包访问权限或包私有。
- 只能被同一个包内的其他类访问。
- 如果一个类没有声明为
public，那么它就是包私有的，并且不能被其他包中的类访问。 - 常用于只在同一个包内部使用的类、方法或变量。
4.private
- 只能被定义它们的类访问。
- 常用于隐藏类的内部实现细节，确保类的封装性。
- 即使子类也无法访问父类的私有成员（除非通过父类提供的公共或受保护的方法）。