this:
1. 解决局部变量与成员变量同名问题
2. 解决方法参数与成员变量同名问题
3. 调用该类的另一个构造方法:在一个类的构造方法中调用另一个构造方法,可以使用this()的方式调用,括号中的参数表示目标构造方法的参数。this()必须作为构造方 法的第一条语句,this只能在非static中使用。
public class ConstructorOverload
{
public ConstructorOverload()
{
this(3);
System.out.println("test");
}
public ConstructorOverload(int i)
{
System.out.println(++i);
}
public static void main(String[] args)
{
ConstructorOverload col = new ConstructorOverload();
}
}
super
1. 子类使用super()显示调用父类的某个构造方法,super()也必须作为构造方法的第一条语句。super(参数)
public class SuperTest2
{
public static void main(String[] args)
{
Dog dog = new Dog();
dog.run();
}
}
class Animal
{
public void run()
{
System.out.println("animal is running");
}
}
class Dog extends Animal
{
public void run()
{
super.run(); //调用父类的run方法}}
2. 在子类中调用父类中被覆盖的方法: super.methodName(参数)
3. 在子类中访问父类中被隐藏的成员变量: super.variableName
final
1. 修饰属性,表示该属性必能被改写(常量):当修饰基本数据类型时,表示值不能发生改变,当修饰引用类型时,表示该应用类型不能指向其他对象了(所指的地址不能 改变),但该引用所指向的对象的内容是可以发生变化的。
2. 修饰方法:终态方法,不能被重写(override)。
public class FinalTest
{
public static void main(String[] args)
{
H h = new H();
h.output();
}
}
class G
{
public final void output() //不能被重写(override)
{
System.out.println("G");
}
}
class H extends G
{
public void output()
{
System.out.println("H");
}
}
3. 修饰类:终态类,不能被继承(exetend)
static
1. 修饰属性:无论一个类生成了多少个对象,所有这些对象,共同使用唯一一份静态的成员变量;一对象对该静态成员变量进行了修改,其他对象的该静态成员变量的值也 会随之发生变化。可以使用类名.方法名访问
public class StaticTest
{
public static void main(String[] args)
{
/*
MyStatic myStatic = new MyStatic();
MyStatic myStatic2 = new MyStatic();
myStatic.a = 10;
System.out.println(myStatic2.a);
*/
MyStatic myStatic = new MyStatic();
MyStatic.a = 10;
System.out.println(myStatic.a);
}
}
class MyStatic
{
static int a;
}
2. 修饰方法:静态方法只能继承,不能被子类重写。可使用类名.方法名访问
public class StaticTest3
{
public static void main(String[] args)
{
M m = new N();
m.output();
}
}
class M
{
public <span style="font-family: Arial, Helvetica, sans-serif;">static </span>void output()
{
System.out.println("M");
}
}
class N extends M
{
public static void output()
{
System.out.println("N");
}
}
输出j结果:M //若不用static修饰则输出N
3. 修饰代码块
静态代码块的作用是完成一些初始化工作。首先执行静态代码块,然后执行构造方法。 静态代码块在类被加载的时候执行,而构造方法是在生成对象的时候执行;要想调用某个类来生成对象,首先需要将类加载到 Java 虚拟机上(JVM),然后由 JVM 加载这个类来生成对象。
类的静态代码块只会执行一次,是在类被加载的时候执行的,因为每个类只会被加载一次,所以静态代码块也只会被执行一次;而构造方法则不然,每次生成一个对象的时候都会调用类的构造方法,所以 new 一次就会调用构造方法一次
如果继承体系中既有构造方法,又有静态代码块,那么首先执行最顶层的类的静态代码块,一直执行到最底层类的静态代码块,然后再去执行最顶层类的构造方法,一直执行到最底层类的构造方法。注意:静态代码块只会执行一次。
public class StaticTest
{
public static void main(String[] args)
{
new S();
new S();
}
}
class P
{
static
{
System.out.println("P static block");
}
public P()
{
System.out.println("P constructor");
}
}
class Q extends P
{
static
{
System.out.println("Q static block");
}
public Q()
{
System.out.println("Q constructor");
}
}
class S extends Q
{
static
{
System.out.println("S static block");
}
public S()
{
System.out.println("S constructor");
}
}
4.小结:不能在静态方法中访问非静态成员变量;可以在静态方法中访问静态的成员变量。可以在非静态方法中访问静态的成员变量。(静态的只能访问静态的;非静态的可以访问一切)