1.static关键字
static关键字是静态的【类名访问】
static关键字可以修饰:
1.可以修饰变量,被static修饰的变量是静态成员变量【类变量】
1.1 静态成员变量【类变量】可以在本类中的任意一个方法中调用
构造方法/实例方法中,默认类名.静态成员变量名称,也可以this.静态成员变量名称,类名和this可以省略
静态方法中,默认类名.静态成员变量名称,类名可以省略
构造方法/实例方法/静态方法中,默认类名.静态成员变量名称,类名可以省略
package com.wangxing.statictest1;
public class MyClass {
//可以修饰变量--被static修饰的变量是静态成员变量【类变量】
public static String name="zhangsan";
//构造方法
public MyClass(){
//默认类名.静态成员变量名称
System.out.println(MyClass.name);
//this.静态成员变量名称
System.out.println(this.name);
//类名和this可以省略
System.out.println(name);
}
//实例方法
public void shili(){
//默认类名.静态成员变量名称
System.out.println(MyClass.name);
//this.静态成员变量名称
System.out.println(this.name);
//类名和this可以省略
System.out.println(name);
}
//静态方法
public static void staticMethod(){
//默认类名.静态成员变量名称
System.out.println(MyClass.name);
//类名和this可以省略
System.out.println(name);
}
}
1.2 静态成员变量【类变量】可以在其他类中的任意一个方法中调用
可以类名调用,也可以对象调用。
package com.wangxing.statictest1;
public class MyClass {
//可以修饰变量--被static修饰的变量是静态成员变量【类变量】
public static String name="zhangsan";
}
package com.wangxing.statictest1;
public class OtherClass {
//构造方法
public OtherClass(){
//类名.静态成员变量名称
System.out.println(MyClass.name);
MyClass mc=new MyClass();
//对象.静态成员变量名称
System.out.println(mc.name);
}
//实例方法
public void shili(){
//类名.静态成员变量名称
System.out.println(MyClass.name);
MyClass mc=new MyClass();
//对象.静态成员变量名称
System.out.println(mc.name);
}
//静态方法
public static void staticMethod(){
//类名.静态成员变量名称
System.out.println(MyClass.name);
MyClass mc=new MyClass();
//对象.静态成员变量名称
System.out.println(mc.name);
}
}
2.可以修饰方法,被static修饰的方法是静态方法【类方法】
2.1 静态方法可以在本类中的任意一个方法中调用
构造方法/实例方法中,默认类名.静态方法,也可以this.静态方法,类名和this可以省略
静态方法中,默认类名.静态方法,类名可以省略
构造方法/实例方法/静态方法中,默认类名.静态方法,类名可以省略
package com.wangxing.statictest2;
public class TestClass {
//可以修饰方法,被static修饰的方法是静态方法【类方法】
public static void staticMethod(){
System.out.println("静态方法【类方法】");
}
//构造方法
public TestClass(){
TestClass.staticMethod();
this.staticMethod();
staticMethod();
}
//实例方法
public void shili(){
TestClass.staticMethod();
this.staticMethod();
staticMethod();
}
//静态方法
public static void testStatic(){
TestClass.staticMethod();
staticMethod();
}
}
2.2 静态方法可以在其他类中的任意一个方法中调用
可以类名调用,也可以对象调用。
package com.wangxing.statictest2;
public class TestClass {
//可以修饰方法,被static修饰的方法是静态方法【类方法】
public static void staticMethod(){
System.out.println("静态方法【类方法】");
}
}
package com.wangxing.statictest2;
public class OtherClass {
public OtherClass(){
//类名.静态方法
TestClass.staticMethod();
TestClass tc=new TestClass();
//对象.静态方法
tc.staticMethod();
}
public void shili(){
//类名.静态方法
TestClass.staticMethod();
TestClass tc=new TestClass();
//对象.静态方法
tc.staticMethod();
}
public static void staticMethod(){
//类名.静态方法
TestClass.staticMethod();
TestClass tc=new TestClass();
//对象.静态方法
tc.staticMethod();
}
}
总结:
1.同一个类中,构造方法/实例方法中访问静态变量/静态方法,可以类名,也可以this,类名和this可以省略;静态方法中访问静态变量/静态方法,默认类名访问,类名可以省略。
2.其他类中,构造方法/实例方法/静态方法中访问静态变量/静态方法,可以类名访问,也可以对象访问
3.静态方法中使用this.
4.同一个类中静态方法中,不能访问当前类中的实例元素。
2.this关键字 【当前类对象】
this关键字出现类中的方法里,表示使用当前类默认的构造方法创建的当前类对象
this代替了new 构造方法创建对象。
this当前类对象
在同一个类中,我们要使用类中的变量和方法时,需要对象调用
我们应该new 构造方法()创建对象,然后使用创建的对象类调用类中的变量和方法
package com.wangxing.demo1;
public class MyClass {
public String shilibianliang="";
public static String staticbianliang="";
public MyClass(){
System.out.println(new MyClass().shilibianliang);
System.out.println(new MyClass().staticbianliang);
new MyClass().testMethod();
new MyClass().staticMethod1();
MyClass mc=new MyClass();
System.out.println(mc.shilibianliang);
System.out.println(mc.staticbianliang);
mc.testMethod();
mc.staticMethod1();
}
public void shili(){
System.out.println(new MyClass().shilibianliang);
System.out.println(new MyClass().staticbianliang);
new MyClass().testMethod();
new MyClass().staticMethod1();
MyClass mc=new MyClass();
System.out.println(mc.shilibianliang);
System.out.println(mc.staticbianliang);
mc.testMethod();
mc.staticMethod1();
}
public static void staticMethod2(){
System.out.println(new MyClass().shilibianliang);
System.out.println(new MyClass().staticbianliang);
new MyClass().testMethod();
new MyClass().staticMethod1();
MyClass mc=new MyClass();
System.out.println(mc.shilibianliang);
System.out.println(mc.staticbianliang);
mc.testMethod();
mc.staticMethod1();
}
public void testMethod(){
System.out.println("测试用的实例方法");
}
public static void staticMethod1(){
System.out.println("测试用的静态方法");
}
}
this关键字出现类中的方法里,表示使用当前类默认的构造方法创建的当前类对象
this当前类对象
this代替了new 构造方法创建对象。
静态方法中不能使用this
package com.wangxing.demo1;
public class MyClass2 {
public String shilibianliang="";
public static String staticbianliang="";
public MyClass2(){
//this===new MyClass2()
System.out.println(this.shilibianliang);
System.out.println(this.staticbianliang);
this.testMethod();
this.staticMethod1();
}
public void shili(){
System.out.println(this.shilibianliang);
System.out.println(this.staticbianliang);
this.testMethod();
this.staticMethod1();
}
//静态方法中不能使用this
public static void staticMethod2(){
//System.out.println(this.shilibianliang);
//System.out.println(this.staticbianliang);
//this.testMethod();
//this.staticMethod1();
MyClass2 mc=new MyClass2();
System.out.println(mc.shilibianliang);
System.out.println(mc.staticbianliang);
mc.testMethod();
mc.staticMethod1();
}
public void testMethod(){
System.out.println("测试用的实例方法");
}
public static void staticMethod1(){
System.out.println("测试用的静态方法");
}
}
3.super关键字【父类对象/构造方法】
super关键字出现在子类中,表示父类对象/父类构造方法
如果super关键字后面有"()",表示父类构造方法
如果super关键字后面没有"()",表示父类对象
super()---父类无参数构造方法
super(参数)---父类有参数构造方法
super.变量名称---此时super表示父类对象,调用父类成员变量
super.方法名称(参数)---此时super表示父类对象,调用父类方法
子类的实例方法中不能使用super()/super(参数)调用父类构造方法
子类的静态方法中不能使用super。
package com.wangxing.test1;
//父类
public class Person {
public String pername="Person中的实例变量";
public static String perstatic="Person中的静态变量";
public Person(){
System.out.println("父类无参数构造方法");
}
public Person(String name){
System.out.println("父类有参数构造方法");
}
public void personShiLi(){
System.out.println("父类中的实例方法");
}
public static void personStatic(){
System.out.println("父类中的静态方法");
}
}
package com.wangxing.test1;
public class SunClass extends Person{
public SunClass(){
//super()---父类无参数构造方法
//super();
//super(参数)---父类有参数构造方法
//super("zhangsan");
System.out.println("子类SunClass的构造方法");
//super.变量名称---此时super表示父类对象,调用父类成员变量
System.out.println("super.变量名称=="+super.pername);
System.out.println("super.变量名称=="+super.perstatic);
//super.方法名称(参数)---此时super表示父类对象,调用父类方法
super.personShiLi();
super.personStatic();
}
public void sunShiLi(){
System.out.println("子类中的实例方法");
//子类的实例方法中不能使用super()/super(参数)调用父类构造方法
//super()---父类无参数构造方法
//super();
//super(参数)---父类有参数构造方法
//super("zhangsan");
//super.变量名称---此时super表示父类对象,调用父类成员变量
System.out.println("super.变量名称=="+super.pername);
System.out.println("super.变量名称=="+super.perstatic);
//super.方法名称(参数)---此时super表示父类对象,调用父类方法
super.personShiLi();
super.personStatic();
}
//子类的静态方法中不能使用super。
public static void sunStatic(){
System.out.println("子类中的静态方法");
//子类的实例方法中不能使用super()/super(参数)调用父类构造方法
//super()---父类无参数构造方法
//super();
//super(参数)---父类有参数构造方法
//super("zhangsan");
//super.变量名称---此时super表示父类对象,调用父类成员变量
//System.out.println("super.变量名称=="+super.pername);
//System.out.println("super.变量名称=="+super.perstatic);
//super.方法名称(参数)---此时super表示父类对象,调用父类方法
//super.personShiLi();
//super.personStatic();
}
}
4.final关键字
final关键字中文含义为最终的意思
1.可以修饰java类,被final关键字修饰java类不能被继承,没有子类
package com.wangxing.test1;
//final关键字可以修饰java类
public final class TestClass {
}
package com.wangxing.test1;
//被final关键字修饰java类不能被继承,没有子类
//public class SunClass extends TestClass{
//}
2.可以修饰变量,被final修饰的变量,不能被重新赋值
package com.wangxing.test1;
public class TestMain {
public static void main(String[] args) {
final String name="zhangsan";
//name="lisi"; //被final修饰的变量,不能被重新赋值
System.out.println(name);
}
}
3.可以修饰方法,被final修饰的方法,不能被重写
package com.wangxing.test2;
public class TestClass {
public final void testClassShiLi(){
System.out.println("TestClass类的实例方法");
}
}
package com.wangxing.test2;
public class SunClass extends TestClass{
//public void testClassShiLi(){
//System.out.println("SunClass子类重写父类方法");
//}
}