java基础学习9(final、抽象类、接口)

final

final关键字修饰一个类时该类不能被继承
final关键字修饰一个函数时该函数不能被重写
final关键字修饰一个基本数据成员变量时该变量不能修改值
final关键字修饰一个引用类型变量时该变量不能被指向新的对象

常量的修饰符

public static final

finally

格式:

try{
}catch(){
}finally{
}

使用场景:finally关键字是对 Java 异常处理模型的最佳补充。finally 结构使代码总会执行，而不管有无异常发生。

FileWriter fileWriter = null;
        FileReader fileReader = null;

        try {
            fileReader = new FileReader("/Users/alex/Downloads/img/a.txt");
            fileWriter = new FileWriter("/Users/alex/Downloads/img/a_copy.txt");

            int length = 0;
            char[] chars = new char[1024];
            while ( (length = fileReader.read(chars)) != -1 ){
                fileWriter.write(chars,0,length);
                fileWriter.flush();
            }
        }catch (IOException e){
            throw new RuntimeException(e);
        }finally {
            try {
                if (fileReader != null){
                    fileReader.close();
                }
            } catch (IOException e) {
                throw new RuntimeException(e);
            }finally {
                try {
                    if (fileWriter != null){
                        fileWriter.close();
                    }
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }

上面代码就保证了无轮程序出行了什么错误，close()都会被执行。

抽象类

关键字:abstract

1. 抽象类中可以只有非抽象函数、只有抽象函数、抽象函数与非抽象函数，非抽象类中一定不能有抽象函数
2. 抽象类可以有自己的构造函数，但是不能new 抽象类本身
3. 一个类继承了抽象类那么就必须重写该类所有的抽象函数

注意:

1. abstract不能与static关键字一起使用**(原因:static关键字修饰的成员可以直接使用类名调用，但是abstract函数并没有实体，所以无实际意义)**
2. abstract不能与final关键字一起使用**(原因:继承了抽象类则必须重写该类的函数，而final修饰的函数是不可以被重写的)**
3. abstract不能与private关键字一起使用**(原因:private修饰的函数是可以被子类继承的没错，但是该函数对子类是不可见的也就是说只能继承不可使用，即使你在子类定义一个相同的函数实际意义上来说也不是重写)**

//动物类--->抽象类
abstract class Animal{
	
	String name;

	String  color;

	public Animal(String  name,String color){
		this.name = name;
		this.color = color;
	}
	

	//非抽象的方法
	public void eat(){
		System.out.println(name+"吃粮食");
	}

	//移动...
	public abstract void run();
}



//狗 是属于动物中一种 
class Dog extends Animal{

	public Dog(String name,String color){
		super(name,color);
	}

	public void run(){
		System.out.println(name+"四条腿跑得很快...");
	}
}


//鱼 是属于动物中一种
class Fish extends Animal{


	public Fish(String name,String color){
		super(name,color);
	}


	public void run(){
		System.out.println(name+"摇摇尾巴游啊游！");
	}
}


class Demo3 {

	public static void main(String[] args) 
	{
		/*
		Dog d = new Dog("牧羊犬","棕色");
		d.run();

		//创建一个鱼对象
		Fish f  = new Fish("锦鲤","金黄色");
		f.run();
		*/

		Animal a = new Animal();

	}
}

接口

格式

interface 接口名{
	
}

注意:

1. 接口内所有的函数都是抽象函数 public abstract
2. 接口类所有的成员变量都是常量 public static final
3. 接口不能创建对象也不能有构造函数

类与接口:

1. 非抽象类实现一个接口时，必须要把接口中所有方法全部实现。
2. 抽象类实现一个接口时，可以实现也可以不实现接口中的方法。
3. 一个类可以实现多个接口 。

接口与抽象类的区别

1. java是单继承多实现也就是一个类只可以继承一个抽象类但是可以实现多个接口
2. 抽象类有构造函数，接口没有构造函数。
3. 抽象类中的成员不强制要求都被abstract修饰，但是接口中就必须都是被abstract修饰（虽然abstract可以不写，但是会默认被abstract修饰）
4. 接口是对动作的抽象，抽象类是对事物的抽象。