final关键字
final：最终的
final：可以修饰 方法、成员变量、局部变量。
final 修饰类，则该类不能有子类
final 修饰方法：该方法不能被重写(覆盖)
final 修饰局部变量，其值不能被改变，即该变量只能被赋值一次；
成为常量(此时变量名通常用大写字母表示，称为字符串常量)。
final 修饰成员变量：如修饰引用类型成员变量时，则此引用类型变量将不能指向其他对象
举例说明如下：
class TEs
{
final public void show()
{
System.out.println("明天下午我要去跑步");
}
}
final class Test//final修饰类：则该类不能有子类
{
int a,b;
}
/*无法从最终Test进行继承
class Te extends Test
{
int a;
String aee;
}
*/
class te extends TEs
{
/*te中的show()无法覆盖TEs中的show():亦即final修饰的show()方法不能被重写
public void show()
{
System.out.println("周末你要去干嘛呢");
}
*/
}
class Demo01
{
public static void main(String[] args)
{
final int num=21;//final修饰局部变量：其值不能被改变
/*num=45; 无法为最终num分配值*/
System.out.println(num);
te t=new te();
t.show();
}
}抽象类及其特点：
关键字 abstract ：抽象的
抽象类的定义：再提取父类的过程中，某一个共性方法在子类中各有不同的实现方式，那么该方法就要
修饰为abstract 该类就是抽象类了，此时也要将该类修饰为abstract
抽象类的特点：
(1).抽象方法一定在抽象类中
(2).抽象方法和抽象类都是用关键字abstract
(3).抽象类不能创建对象 即不能实例化
(4).抽象类中的方法要想被使用，必须由子类重写所有的抽象方法，创建子类对象来调用;
如果只是覆盖了部分,会继承父类的抽象方法，那么子类还是抽象类。
(5).抽象类中可以含有非抽象方法和抽象方法、可以没有抽象方法。
例1：写一个抽象类 形状类Shape 里面含有抽象方法 获取面积double getArea() 和周长double getGirth()
再分别写两个子类圆：Circle 和 矩形：Rectangle --------(使用键盘录入形状的参数值)
最后写一个测试类Test 分别实例化一个圆和矩形对象，计算它们的周长和面积。
import java.util.Scanner;//导入java.util包下的Scanner类
abstract class Shape//创建抽象类Shape
{
public abstract double getArea();//这是描述获取面积的抽象方法
public abstract double getGirth();//这是描述获取周长的方法
}
class Circle extends Shape//定义了Circle 继承 Shape类
{
public static final double PI=Math.PI;//通过Math类获取圆周率
private double radius;
public void setRadius(double radius)//给半径赋值的方法
{
if(radius<=0)
System.out.println("数据不合法");
else
this.radius=radius;
}
public double getRadius()//获取半径值得方法
{
return radius;
}
public double getArea()//重写抽象类Shape中的抽象方法
{
return PI*radius*radius;
}
public double getGirth()
{
return 2*PI*radius;
}
}
class Rectangle extends Shape
{
private double length;
private double width;
public void setLength(double length)
{
if(length<=0)
System.out.println("数据不合法");
else
this.length=length;
}
public double getLength()
{
return length;
}
public void setWidth(double width)
{
if(width<=0)
System.out.println("数据不合法");
else
this.width=width;
}
public double getWidth()
{
return width;
}
public double getArea()
{
return length*width;
}
public double getGirth()
{
return (length+width)*2;
}
}
class Test//这是测试类
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);//创建键盘录入对象
System.out.println("请输入圆的半径r");//提示输入
double r=sc.nextDouble();//存储录入值
System.out.println("请输入矩形的长x");
double x=sc.nextDouble();
System.out.println("请输入矩形的宽y");
double y=sc.nextDouble();
Circle c=new Circle();//创建圆的对象
c.setRadius(r);//通过对象调用赋半径值得方法给半径赋值
System.out.println("半径r="+c.getRadius()+","+"面积S="+c.getArea()+"周长C="+c.getGirth());
System.out.println("----------------------------------------------------------------------");
Rectangle rec=new Rectangle();
rec.setLength(x);
rec.setWidth(y);
System.out.println("长x="+rec.getLength()+"宽y="+rec.getWidth()+","+"面积S="+rec.getArea()+"周长C="+rec.getGirth());
}
}
关键字final和abstract的区别
final 修饰的方法不能被重写，abstract修饰的方法必须要重写。
补充：
private 修饰的方法不能被重写，abstract修饰的方法必须要重写。
static 修饰的方法可以直接用类名调用，abstract修饰的不能。
接口的定义和使用
什么是接口：
接口是个特殊的抽象类，当抽象类中的方法全部是抽象的，那么该抽象类就可以通过关键字 abstract
来修饰即通过接口来定义。
接口的定义形式：
interface 接口名
{
public static final 数据类型 变量字母大写名 = 变量值;//全局常量
public abstract 返回值类型 方法名(类型1 参数1,类型2 参数2...) ;//抽象方法
}
由此可见，接口的修饰符是固定的。
接口的特点：
(1).接口中的所有方法都是抽象的，所有属性都是常量
(2).一个类可以同时实现多个接口即接口允许多实现
(3).接口与接口之间允许多继承
知识拓展：
类与类之间是继承关系
类与接口之间是实现关系
接口与接口之间是继承关系
举例：
interface inter1//定义接口inter1
{
public static final int NUM=666;//定义字符串常量的值
public abstract void show();//定义抽象的方法
}
interface inter2//定义接口inter2
{
public abstract void show();
}
class Test implements inter1,inter2//定义实现接口inter1和inter2(implements：实现)的Tst类
{
public void show()//重写抽象方法show()
{
System.out.println("Hello");
}
}
class DemoInterface
{
public static void main(String[] args)//main函数：程序运行的入口
{
Test test=new Test();//创建对象test
test.show();//通过对象访问成员函数
System.out.println(test.NUM);//输出(通过对象访问接口inter1中的NUM)
System.out.println(Test.NUM);//通过类名访问
System.out.println(inter1.NUM);//通过接口名访问
}
}
接口的好处：它对外暴露规则，提高了程序的扩展性。