JavaSE(八)--abstract、static、final

1.abstract

扩展修饰符,抽象的.

1.1:抽象类

用abstract修饰的类叫抽象类.

1.1.1:抽象类特点:

• 抽象类不能实例化(不能创建对象),但是抽象类有构造方法,
• 作用：供子类调用.
• 抽象类中可以有0到多个抽象方法,也可以有0到多个普通方法.

1.1.2:抽象类适用场景:

• 当一个类创建对象时没有意义,就可以将这个类定为抽象类;
• 当一个类中有一个方法为抽象方法时,这个类必须定为抽象类.

1.1.3:抽象类的作用

让子类继承,从而实现代码复用;
规定子类必须拥有的行为.

1.2:抽象方法

用abstract修饰的方法叫抽象方法.

1.2.1:抽象方法的特点:

• 抽象方法没有方法体(连大括号都没有).
• 抽象方法必须被子类重写,除非子类也是抽象的,就让后代类去重写.
• 抽象方法必须写在抽象类中.

1.2.2:抽象方法适用场景

当一个方法无法确定具体实现(具体功能怎么执行),这个方法就可以定为抽象方法.

1.2.3:抽象方法的作用

规定了子类必须拥有的行为.

//eg:/**
 * 宠物类,抽象类
 */
public abstract class Pet{
	/**
	 * 昵称的属性
	 */
	public String nickName;
	/**
	 * 品种的属性
	 */
	public String brand;
	
	public Pet() {
		System.out.println("这是pet类无参构造");
	}

	/**
	 * 吃的方法,抽象方法
	 */
	public abstract void eat();
	
	/**
	 * 实例方法
	 */
	public void show() {
		System.out.println("这是一个实例方法");
	}
}

/**
 * 猫类,继承宠物类
 */
public class Cat extends Pet{
	
	public Cat() {
		System.out.println("这是猫类无参构造");
	}
	
	/**
	 * 重写父类吃的方法
	 */
	@Override
	public void eat() {
		System.out.println("猫在吃鱼");
	}
}

2.static

扩展修饰符,静态的.可以用static修饰成员变量和方法.用static修改的变量比较耗内存

2.1:静态变量

用static修饰的成员变量叫静态变量.

• 静态变量属于类,类的所有对象共享.
• 静态变量的生命周期随着类的加载而产生,随着类的销毁而结束.
• 静态变量的缺点耗内存
• 静态变量调用语法:类名.静态变量名;(推荐)
  对象名.静态变量名;
• 静态变量的使用场景:当一个类的所有对象共享一个属性时,这个属性就可以定为 静态变量.

2.2:静态方法

用static修饰的方法叫静态方法.

• 1.1在静态方法中只能直接调用静态属性和静态方法,不可以直接调用非静态属性和非静态方法.如果一定要在静态的方法中调用非静态属性和方法,可以用对象调用

• 1.2在实例方法中既可以直接调用成员变量和成员方法,也可以直接调用静态变量和静 态方法.

• 2:静态方法可以被继承,不能被重写,没有多态.

• 3:静态方法调用语法:类名.静态方法(实参列表);(推荐)
  对象名.静态方法(实参列表);

• 4:静态方法的适用场景:当一个类为工具类时,这个类中方法就声明静态方法,方便调用.

2.3:静态块

静态是在类加载时加载,一生只执行一次.

• 语法

   static{
   	代码块;
   }

• 作用:在类加载时完成初始化操作.

• 静态代码块中只能直接调用静态的属性或方法,不能直接调用非静态东西.

//eg:/**
 * 员工类
 */
public class Employee {
	/**
	 * 姓名属性,成员变量
	 */
	public String empname;
	
	/**
	 * 公司名称属性,静态变量
	 */
	public static String company;

	/**
	 * 静态块
	 */
	static {
		//empname="张三";
		company="xxx公司";
		//show1();
		show3();
	}
	
	/**
	 * 普通(实例)方法
	 */
	public void show1() {
		System.out.println("这是一个实例方法show1");
		//在实例方法中可以直接调用成员变量,也可直接调用静态变量
		System.out.println("姓名:"+this.empname+",公司名称为:"+company);
		//在实例方法中可以直接调用实例方法,也可直接调用静态方法
		show2();
		show3();
	}
	
	/**
	 * 普通(实例)方法
	 */
	public void show2() {
		System.out.println("这是一个实例方法show2");
	}
	
	/**
	 * 静态方法
	 */
	public static void show3() {
		System.out.println("这是一个静态方法show3");
		//在静态方法中只能直接调用静态属性和静态方法,不可以直接调用非静态属性和非静态方法.
		System.out.println("公司名称为:"+company);
		//show2();
		show4();
		
		//如果一定要在静态的方法中调用非静态属性和方法,可以用对象调用
		//创建对象
		Employee e1=new Employee();
		System.out.println("姓名:"+e1.empname);
		e1.show2();
	}
	
	/**
	 * 静态方法
	 */
	public static void show4() {
		System.out.println("这是一个静态方法show4");
	}
}
	
		  public static void main(String[] args) {
		//创建对象
		Employee e1=new Employee();
		e1.empname="张三";
		//用对象调用静态变量
		//e1.company="xx公司";
		//用类名调用静态变量
		Employee.company="xx公司";
		
		Employee e2=new Employee();
		e2.empname="田七";
		
//		System.out.println("员工姓名:"+e1.empname+",公司:"+e1.company);
//		System.out.println("员工姓名:"+e2.empname+",公司:"+e2.company);
		//用对象调用静态方法
		e2.show4();
		//用类名调用静态方法
		Employee.show4();
	}

2.4:(了解)动态块

创建对象时执行.动态块在构造方法执行之前执行.

• 语法

	{
		代码块;
	}

• 作用:完成对象的初始化操作.
• 类的加载顺序:先加载静态变量,静态块,成员变量,动态块,构造方法.

2.5:(了解)静态导入

当一个类中方法为静态方法,且调用比较频繁,不想每次写类名调用方法,这时就可以用静态导入.

• 语法

import static 包名.类名.*;

//eg:/**
 * 静态导入,让Arrays类中所有静态的属性和方法,在当前类直接用,不用类名调用.
 * 如果用类名调用静态属性和方法,那就不能静态导入包用的是普通导入包.
 */
import static java.util.Arrays.*;

/**
 * 静态导入

 */
public class Test2 {

	public static void main(String[] args) {
		//准备一个数组
		int[] nums= {5,8,1,7,6,3};
		
		System.out.println("原数组为:");
		for (int i : nums) {
			System.out.print(i+"\t");
		}
		
		//对数组进行升序排序,因为有静态导入,所以静态方法直接写方法名用
		sort(nums);
		
		System.out.println("\n排序后数组为:");
		for (int i : nums) {
			System.out.print(i+"\t");
		}
		
		//对数组进行二分查询,因为有静态导入,所以静态方法直接写方法名用
	    binarySearch(nums, 8);
		
	}

}

3.final

扩展修饰符,最终的.可以用来修饰类,变量,方法.

3.1:最终类

用final修饰的类叫最终类,最终类不能被继承.

3.2:最终方法

用final修饰的方法叫最终方法,最终方法不能被重写,但是可以被继承.

3.3:常量

用final修饰的变量叫常量.常量一但赋值不可更改.

• 成员常量:在类中方法外直接声明常量.
  成员常量可以声明的同时赋值,也可以在动态代码块中赋值,还可以在当前类的构造方法中赋值,但是要确保每个构造方法都给常量赋值了.
• 局部常量:在方法中声明的常量叫局部常量.
  局部常量在声明的同时赋值或先声明,再赋值.
• 静态常量:在类中方法外直接声明静态常量.
  静态常量可以声明的同时赋值或静态块中赋值.

//eg:
public class Pet {
	public String nickName;

	/**
	 * 成员常量
	 */
	public final int count;
	
	/**
	 * 静态成员常量 
	 */
	public static final int num1;
	
	static{
		num1=2;
	}
	
//	{
//		count=2;
//	}
	
	public Pet() {
		this.count=4;
	}
	
	public Pet(String nickName, int count) {
		super();
		this.nickName = nickName;
		this.count = 3;
	}
	
	public final void eat() {
		System.out.println("吃");
		final int num2=2;
		//num2=1;
	}
}

4.static，final，abstract小结

• final不可以与abstract一起连用.
• abstract不可以与static一起连用.

个人笔记，思路，仅供参考