Day16-关键字

Day16-关键字

static

概念：

静态可以修饰属性和方法称为静态属性（类属性）、静态方法（类方法）

静态成员是全类所有对象共享的成员

全类中只有一份，不因创建多个对象而产生多份

不必创建对象，可直接通过类名访问

public class TestStaticDemo1 {
	public static void main(String[] args) {
		
		MyClass mc1 = new MyClass();
		//mc1.a = 10;
		MyClass.a = 10;//同上
		//这里mc1.a的值还为10
		System.out.println("mc1："+mc1.a);
		
		
		MyClass mc2 = new MyClass();
		//mc2.a = 20;
		MyClass.a = 20;
		//这里mc1.a的值就变为20了
		System.out.println("mc1："+mc1.a+"\t"+"mc2："+mc2.a);
	}
}

class MyClass{
	//静态属性a 全类共享
	static int a;
}

静态方法的特点

静态方法允许直接访问静态成员

静态方法不能直接访问非静态成员

静态方法中不允许使用this或是super关键字

静态方法可以继承，不能重写、没有多态

/**
 * 静态方法允许直接访问静态成员（属性、方法）
 * 静态方法不能直接访问非静态成员
 * 静态方法中不允许出现this或super关键字
 * 静态方法可以继承，不可重写，没有多态
 */
public class TestStaticDemo3 {
	public static void main(String[] args) {
		//不同类之间静态方法必须通过类名访问
		OtherClass.m1();
		//静态方法中不允许出现this或super关键字
		//System.out.println(this);
		//System.out.println(super);
		OtherClass1.m1();
		OtherClass1.m2();
		
		new OtherClass1().show();
	}
}
class OtherClass{
	static int b;//静态属性
	int a;//实例属性
	public static void m1() {
		System.out.println("m1方法"+b);
		//本类之间静态方法可以通过方法名或通过类名调用
		m2();
	}
	public static void m2() {
		System.out.println("m2方法");
		//System.out.println(a);不能直接访问非静态 可以通过对象来访问
		OtherClass o = new OtherClass();
		System.out.println(o.a);
	}
	public void show() {
		System.out.println("1");
	}
}
class OtherClass1 extends OtherClass{
	//相当于自身又创建了个m2方法，不是重写
	public static void m2() {
		System.out.println("OtherClass1m2方法");
	}
	//不是静态方法，可重写
    public void show() {
    	System.out.println("2");
	}
}

代码块

局部代码块

动态代码块

静态代码块

public class TestStaticDemo1 {
	public static void main(String[] args) {
		int a = 12;
		//局部代码块，基本不用，缩小变量的使用范围，节约空间
		{
			int age = 18;
			System.out.println(age);
		}
		//System.out.println(age);error
		System.out.println(a);
	}
}

/**
 * 动态代码块
 */
public class Person {
	
	//实例属性
	String name;
	int age;
	
	//在构建对象时执行动态代码块，初始化对象属性 编译时，动态代码块会优化到构造方法中
	//构造方法
	public Person() {
		System.out.println("构造方法执行了");
	}
	
	//动态代码块
	{
		System.out.println("动态代码块执行了");
	}
	
	//普通方法
	public void show() {
		System.out.println("姓名是"+name+"年龄是"+age);

	}
	
}

public class TestPerson {
	public static void main(String[] args) {
		Person xm = new Person();
		Person xh = new Person();
	}
}

/**
 * 静态代码块
 */
public class Student {
	int stuNum;
	String name;
	
	static String country = "中国";
	//静态代码块：类加载时（初始化阶段）会执行，只执行一次，初始化类的属性
	static {
		System.out.println(Student.country);
	}
	public Student() {
		System.out.println("构造方法执行了");
	}
	
	public void show() {
		System.out.println(stuNum+"\t"+name);
	}
}

public class TestStudent {
	public static void main(String[] args) {
		
		Student xm = new Student();
		Student xh = new Student();
	}
}

总结

A.static修饰的成员为静态成员，无需创建对象，可直接通过类名访问。

B.静态方法不能直接访问非静态成员。

C.静态方法中不能使用this或super。

D.静态方法可以继承、不能重写、没有多态。

E.静态代码块在类加载时被执行，且只执行一次。

final

概念：最后的，不可更改的

可修饰的内容：

类（最终类）

方法（最终方法）

变量（最终变量）

/**
 * final修饰类
 * final修饰方法
 */
public final class Student {
	int stuNum;
	String name;
	public Student() {
		
	}
	public void show() {
		System.out.println(stuNum+"\t"+name);
	}	
}
/*1、final修饰类不可被继承
class SmallStudent extends Student{
	//2、不可重写
	public void show() {
		System.out.println(stuNum+"\t"+name);
	}
}
*/

/**
 * 1、final修饰变量
 * 2、final修饰成员变量
 * 3、final修饰静态成员变量
 * 4、final修饰对象
 */
public class TestFinal {
	//2、final修饰成员变量 用之前要初始化
	//声明时赋值，或者动态代码块，构造方法中赋值，只能赋值一次
	final String name = "tom";
	
	//3、final修饰静态成员变量
	//声明时赋值或静态代码块赋值 只能赋值一次
	static final int age = 18;
	
	public static void main(String[] args) {
		//1、final修饰局部变量 为常量 不能修改
		final int NUM = 10;
		//NUM = 20;
		System.out.println(NUM);
		
		//4、final修饰对象 （对象常量）
		//对象的地址值不能改变，但属性可以改变
		Student student = new Student();//前面加final就会报错
		student = new Student();
	}
}

总结

A.final修饰类：此类不能被继承

B.final修饰方法，此方法不能被重写（覆盖）

C.final修饰变量：此变量的值不能被改变（无初始值、只允许赋值一次）

final修饰局部变量 为常量 不能修改

final修饰成员变量 用之前要初始化。声明时赋值，或者动态代码块，构造方法中赋值，只能赋值一次

final修饰静态成员变量。声明时赋值或静态代码块赋值 只能赋值一次

final修饰对象 （对象常量）
对象的地址值不能改变，但属性可以改变

D.abstract不能和final使用

E.abstract不能和static使用

接口

未完待续...