Java学习笔记（八）abstract，final，变量及接口

1. abstract关键字

抽象类和抽象方法都以关键字abstract修饰.java中,抽象方法没有方法体,以一紧跟在声明之后的";"结束。

abstract class Figure {// 抽象类，一般作为其他类的超类
	protected double x;

	Figure() {

	}

	Figure(double x1) {
		this.x = x1;
	}

	abstract public double area(); // 抽象方法

	@Override
	public String toString() {
		return "x=" + x;
	}
}

class Circle extends Figure {
	public Circle(double x1) {
		super(x1);
	}

	public double area() {// 具体方法
		return 3.1415926 * x * x;
	}

	public String toString() {// 方法覆盖
		return "圆：\t" + super.toString() + "\tarea:" + this.area();
	}
}

class Rectangle extends Figure {
	double y;

	public Rectangle() {

	}

	public Rectangle(double a, double b) {
		super(a);
		this.y = b;
	}

	public double area() {// 具体方法
		return x * y;
	}

	public String toString() {// 方法覆盖
		return "长方形：\t" + super.toString() + "\ty=" + this.y + "\tarea:"
				+ this.area();
	}
}

public class testFigure {
	public static void main(String[] args) {
		Rectangle r = new Rectangle(10.0, 20.0);
		Circle c = new Circle(10.0);
		Figure f = new Rectangle(30.0, 30.0);//自动类型转换
		System.out.println(r.toString());
		System.out.println(c.toString());
		System.out.println(f.toString());
	}
}

运行结果：

长方形：	x=10.0	y=20.0	area:200.0
圆：	x=10.0	area:314.15926
长方形：	x=30.0	y=30.0	area:900.0

注意：

（1）如果一个类继承自某个抽象类，而没有实现抽向父类中的抽象方法，则该类必须定义为抽象类。

（2）抽象类不能被实例化。

（3）抽象类的作用是提供一个恰当的父类（一般作为其他类的超类，与final正好相反）

（4）如果一个类里有抽象方法，则这个类就必须声明成抽象的

（5）抽象类中可以没有抽象方法

//如果一个类里有抽象的方法，则这个类就必须声明成抽象的
abstract class Vehicle{
	//该类的没有给出方法体，声明为抽象方法，继承它的类中则需要定义该抽象方法体
	public abstract void calcFuelEffiency();//抽象方法
	
	public abstract void calcTripDistance();//抽象方法
}

abstract class Truck extends Vehicle{
	//一个类中包含有成员方法未实现的话，这个类必须声明为抽象类
	public Truck(double max_load){
		
	}
	
	public void calcFuelEffiency(){
		
	}
	
	/*
	public void calcTripDistance(){
	
	}
	 */
}

class RiverVarge extends Vehicle{
	
	//类实现了定义的方法，则类不需要定义为抽象类
	public RiverVarge(double max_load){
		
	}
	
	public void calcFuelEffiency(){
		
	}
	
	public void calcTripDistance(){
		
	}
}
public abstract class testAbstract {
	//抽象类中可以没有抽象方法
	public static void main(String[] args) {
		
	}
}<span style="color:#ff0000;">
</span>

2. final关键字

（1）如果一个类没有必要再派生子类，通常可以用final关键字修饰，表明它是一个最终类。

（2）最终方法：用关键字final修饰的方法，既不能被覆盖，也不能被重载，它是一个最终的方法，其方法的定义永远不能改变。

注意：

（1）final类中的方法可以不声明为final方法，但实际上final类中的方法都是隐式的final方法。

（2）final修饰的方法不一定要存在于final类中。

（3）如果一个变量用final修饰，表明它在程序中是不能被修改的常量。

（4）final常量可以在声明的同时赋初值，也可以在构造函数中赋初值。

（5）为了节省内存，我们通常将常量声明为静态的(static)。

（6） 定义类头时，abstract和final不能同时使用。

public class testFinal {
	public static void main(String[] args) {
		// <span style="color:#ff0000;">final修饰复合类型数据时，修饰的是引用地址不能改变，</span>
		//但是指向的堆中的实例具体的值，则是可以改变的，即<span style="color:#ff0000;">引用的成员变量是可以改变的</span>
		final Student p1 = new Student("Tom", "M", 23);
		Student p2 = new Student("Mary", "F", 20);
		System.out.println("final p1:" + p1.toString());

		// p1=p2 //对final对象重新赋值会产生编译错误
		// 以下对final对象中的变量赋值是可以的
		p1.name = p2.name;
		p1.sex = p2.sex;
		p1.age = p1.age;
		System.out.println("final p1:" + p1.toString());
	}
}

class Student {
	String name;
	String sex;
	int age;

	public Student(String n, String s, int a) {
		this.name = n;
		this.sex = s;
		this.age = a;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", sex=" + sex + ", age=" + age + "]";
	}
}

3. 变量

（1）全局变量:全局变量的作用范围是整个类,即在该类的各个方法中可以直接使用。任何对全局变量值的改变,都可能对后续操作产生影响。

（2）局部变量:是指在一个方法或一个方法的程序块中声明的变量,也称为本地变量。局部变量的作用范围是声明该变量的方法或某一方法的程序块内不能在其他地方引用。

（3）全局变量(即成员变量)如果不初始化,则取默认值；局部变量(即本地变量)必须初始化,否则编译时将产生语法错误

（4）各种数据类型的默认值表

变量类型	byte	short	int	long	float	double	char	boolean	引用
默认值	0	0	0	0L	0.0f	0.0d	'\u0000'	false	null

4. 接口

（1）接口是一组方法集，接口中包含的方法都是抽象方法，定义的方法体的任务留给实现该接口的类去完成，接口是用来实现类间（不相关类）多重继承功能的结构。

（2）接口是一种特殊的“类”，而且是一种特殊的“抽象类”，一个类是可以实现多个接口。

（3）接口中所有的方法都默认是public abstract的，并且只有方法头和参数列表，没有方法体。

（4）接口中所有的变量都默认是public static final的。

（5）接口没有构造方法，接口可以继承，而且可以多重继承

（6）接口中的方法体可以由Java语言书写，也可以由其他语言书写，用其他语言书写时，接口方法需要用native关键字修饰

 

接口的功能：

（1）通过接口可以实现不相关类的相同行为，而不需要考虑这些类之间的层次关系

（2）通过接口可以指明多个类需要实现的方法

（3）通过接口可以了解对象的交互界面，而不需要了解对象所对应的类

（4）通过接口可以在运行时动态地定位类所调用的方法

 

定义接口

[public ][interface] 接口名称[extends 父接口名列表]{

//静态常量

[public][static][final]数据类型 变量名 = 值;

//抽象方法

[public][abstract][native]返回值 方法名(参数列表);

}

实现接口

[修饰符] class 类名[extends 父类名][implements 接口A，接口B]{

    类的成员变量和成员方法;

为接口A中的所有方法编写方法体，实现接口A;

为接口B中的所有方法编写方法体，实现接口B;

    …

}

interface Iexample{
	void method1();
	void method2();
}
abstract class Example1 implements Iexample{
	
	//因为只实现了一个方法，所以类Example1需要定义为抽象类
	public void method1(){
		…
}
}

interface A{
	char a = 'A';
	void showa();
}
interface B extends A{
	char b = 'B';
	void showb();
}
interface C{
	char c = 'C';
	void showc();
}
interface D extends B,C{//接口允许多继承
	char d = 'D';
	void showd();
}

class E implements D{
	char e = 'E';
	
	public void showa(){
		System.out.println("这里是接口" + a);
	}
	public void showb(){
		System.out.println("这里是接口"+b);
	}
	public void showc(){
		System.out.println("这里是接口"+c);
	}
	public void showd(){
		System.out.println("这里是接口"+d);
	}
	public void showe(){
		System.out.println("这里是类"+e);
	}
}
public class InterfaceTest1 {
	public static void main(String[] args) {
		E e = new E();
		e.showa();
		e.showb();
		e.showc();
		e.showd();
		e.showe();
	}
}

运行结果：

这里是接口A
这里是接口B
这里是接口C
这里是接口D
这里是类E

注意：

（1）一个类在实现某个接口的抽象方法时，必须以完全相同的方法头，否则，只是在重载一个新方法，而不是实现已有的抽象方法。

（2）接口的抽象方法的访问限制符默认为public，所以在实现这些抽象方法时，必须显式的使用public修饰符，否则将被警告为缩小了接口中定义的方法的访问控制范围。

 

5. 包

（1）包是类和接口的集合，通过关键字package创建，用包来管理名称空间，包消除了不同组的类中潜在的类名冲突问题。

（2）Java中的每一个类都属于一个特定的包，包是有层次的

（3）包定义语句必须是Java源文件中的第一条可执行语句

 

（4）Java常用类库

API包 功能

java.lang 包含Java语言的核心类库

java.util  提供各种实用工具类

java.io    标准输入/输出类

java.net   实现Java网络功能的类库

java.awt   包含了Java图像界面中常用的类和接口

java.applet   提供对通用Applet支持的类和接口

java.security 支持Java程序安全性的类和接口