final和abstract

final关键字

final:最终的，不可改变的
可以修饰的内容有

类:final修饰的类不能有子类
成员方法：final修饰的方法不能重写
成员变量：被final修饰的变量必须先给一个值，这个值是不能被改变的
局部变量：被final修饰的局部变量是一个定值，不能被改变.

public class Demo7 {
	public static void main(String[] args) {
	
	}
}

class Pig{
	final String name = "bingbign";
	
	public void play(int a ) {
		a = 4;
		System.out.println(a);
	}
}


class XiaoPig extends Pig{
	//@Override//重写的意思
	public void play(int a) {
		// TODO Auto-generated method stub
		super.play(a);
	}
}

/*
 * 求圆的面积
 */
public class Demo8 {
	public static void main(String[] args) {
		
		Circle circle = new Circle(2);
		
		System.out.println(circle.getArea());
	}
	
}

class Circle{
	private double r;
	private double PI = 3.14;//符号常量
	public double getArea() {
		return PI*r*r;
	} 
	
	public double getR() {
		return r;
	}

	public void setR(double r) {
		this.r = r;
	}

	public Circle() {
		
	}
	
	public Circle(double r) {
		this.r = r;
	}
}

abstract:抽象的

有两类：可以修饰类或方法
抽象类，抽象方法
抽象类：在继承中，提取父类方法的时候，每个子类都有属于自己的实现方法，父类不能去决定他各自的实现功能，父类就不管了，所以在父类中只写方法的声明，将方法的实现交给子类，在类中只有方法声明的方法称为抽象方法，拥有抽象方法的类称为抽象类
方法的声明：没有方法体的方法
abstract的注意点：

抽象类不一定有抽象方法，有抽象方法的一定是抽象类
继承了抽象类的子类一定要实现父类的抽象方法，如果不实现就要将自己变成抽象的
抽象类不能直接创建对象，必须通过子类实现，所以抽象类一定有子类

比较普通类和抽象类

普通类可以直接创建对象，抽象类不行.
抽象类可以有抽象方法，普通类没有.

比较private、static、final，判断他们是否可以和abstract同时使用
private：被private修饰的方法不可以重写，但是被abstract必须被重写
static：被static修饰的类可以通过类名直接调用，但是被abstract修饰的类必须通过子类实现功能
final：被final修饰的类不能有子类，修饰的方法不能被重写，但是abstract修饰的类必须可以有子类，而且必须能重写.
private、static、final都不能同时与abstract使用

public class Demo2 {
	public static void main(String[] args) {
		//抽象类不能直接创建对象
		//Person person =new Person()；
		//通过子类创建对象
		Student student = new Student();
		
	}
}
//抽象类--拥有抽象方法的一定是抽象类
abstract class Person{
	String name;
	//抽象方法--相当于制定了一个规则
	abstract public void run();
}

/*
 * 两种方式处理继承了抽象类的子类
 * 1.将当前的子类变成抽象类---不好，因为抽象类不能直接创建对象，子类变成抽象类之后还是无法工作
 * 2.在子类中重写抽象的方法，让子类变成一个普通的类
 */
class Student extends Person{
	//重写抽象方法
	@Override
	public void run() {
		System.out.println("run");
	}
}

例子：求圆与矩形的面积

public class Demo3 {
	public static void main(String[] args) {
		Circle c = new Circle(2);
		Rectangle rectange = new Rectangle(2,5);
		
		System.out.println(c.getArea());
		System.out.println(rectange.getArea());
	}
}

abstract class Shape{
	abstract public double getArea();
}

class Circle extends Shape{
	private double r;
	private final double PI = 3.14;
	
	public double getArea() {
		return PI * r * r;
	}
	
	public Circle() {}
	
	public Circle(double r) {
		this.r = r;
	}
}

class Rectangle extends Shape{
	private double length ;
	private double weight ; 
	
	public Rectangle() {}
	
	public Rectangle(double height,double weight ) {
		this.length = height;
		this.weight = weight;
	}
	
	public double getArea() {
		return length * weight;
	}
}

final关键字

abstract:抽象的

猜你喜欢