|
一.final总结
1.final修饰类:表示该类不可继承
final不能修饰interface接口
2.final修饰方法:表示该方法不能被 子类覆盖(即子类不能重写父类的final方法,可以继承)
final不能修饰构造函数
3.final修饰字段属性:表示属性值第一 次初始化后不能被修改
final属性可以直接初始化或在构造函数中初始化
如果属性是直接初始化，则其值不能被其它函数(包括构造函数)修改
4.final修饰函数参数
参数值不能被函数修改
5.final 修饰函数中的局部变量
局部变量被第一次初始化后不能被修改
public void hello() {
final String name;
name = "hi"; //ok
name = "hello"; //error
}
使用final的意义：
之所以要使用final方法，可能是出于对两方面理由的考虑。第一个是为方法“上锁”，防止任何继承类改变它的本来 含义。设计程序时，若希望一个方法的行为在继承期间保持不变，而且不可被覆盖或改写，就可以采取这种做法。
采用final方法的第二个理由是程序 执行的效率。将一个方法设成final后，编译器就可以把对那个方法的所有调用都置入“嵌入”调用里。
二.static总结
1.static修饰成员函数:该成员函数不能使用this对象
static不能修饰构造函数
static不能修饰函数参数
static不能修饰局部成员变量
2.static修饰成员字段
当类被虚拟机加载时，首先按照字段声明的先后顺序对static成员字段进行初始化
3.static 修饰语句块
当类被虚拟机加载时，按照声明顺序先后初始化static成员字段和static语句块
static所修饰的方法和字段是只属于类，所有对象共享。
在static所修饰的函数和语句块中不能使用非static成员字段。
在 JAVA不能直接定义全局变量，是通过static来实现的
在Java中没有const，不能直接定义常量，通过static final来实现
import java.util.*;
/**
*@displays: java关键字的复习
*@auther: http://www.javaweb.cc
*@version: lv 1.0.0
@time:2010-1-31
**/
public class Test{
public static void main(String[] args){
/********************static的使用*********************/
/*
TestStatic a = new TestStatic();
TestStatic b = new TestStatic();
System.out.println(a.num1);
a.num1 = 20;
System.out.println(b.num1);
TestStatic.num1 = 21;
System.out.println(TestStatic.num1);
TestStatic.doSm();
*/
/*****************************************************/
/*******************final的使用**********************/
/*
TestFinal fl = new TestFinal();
System.out.println(fl.num2);
System.out.println(fl.num3);
*/
/*
TestFinal fl1 = new TestFinal();
fl1.fun1();
fl1.fun1(1);
fl1.fun1(1,1);
//fl1.fun1(1,1,1);
TestFinal fl2 = new TestExtFinal();
fl2.fun1();//可以访问父类的final方法
fl2.fun1(1);//可以访问父类的final方法
fl2.fun1(1,1);//调用重写的父类方法
//fl2.fun1(1,1,1);//不能访问父类的私有方法
//fun2调用的区别
//fl2.fun2();//TestFinal fl2 = new TestExtFinal();这种方式实例化的类不能调用自己的final方法
TestExtFinal fl3 = new TestExtFinal();
fl3.fun2();//TestExtFinal fl3 = new TestExtFinal();这种方式实例化的类可以调用自己的final方法
*/
/*****************************************************/
/*
Pair<Object> p = new Pair<Object>(23,"zxfonline");
System.out.println(p.first() + " " + p.second());
for(String s : p.stringList()){
System.out.print(s + " ");
}
*/
/**********************abstract的使用*********************/
/*
AbsClass extAbsClass = new ExtAbsClass1();
extAbsClass.fun1();//调用实现了抽象类的抽象方法
extAbsClass.fun3();//调用没有重写的抽象类的普通方法
extAbsClass.fun4();//调用重写了抽象类的普通方法
AbsSonClass extAbsSClass = new ExtAbsClass2();
extAbsSClass.fun1();//调用实现了抽象类的抽象方法
extAbsSClass.fun3();//调用没有重写的抽象类的普通方法
extAbsSClass.fun4();//调用重写了抽象类的普通方法
*/
/*****************************************************/
/*********************interface的使用********************/
ClsIplIntrfc cl = new ClsIplIntrfc();
cl.fun1();
cl.fun3();
/*****************************************************/
}
}
/**
*关键字static --- 只能修饰方法或属性或作为一个语句块且这个语句块只能有变量不能有方法
**/
class TestStatic{
static int num1 =19;
static int num2 ;
TestStatic(){
num2 = 10;
System.out.println("TestStatic Constructor num2 = " + num2);
}
//static定义的变量会优先于任何其它非static变量，不论其出现的顺序如何
static{
num2 = 11;
System.out.println("TestStatic static num2 = " + num2);
//static 语句块中不能有方法
/*
void show(){
System.out.println("TestStatic static num2 = " + ++num2);
}
*/
}
//静态方法直接用--- 类名.方法名
static void doSm(){
System.out.println("static function sm of class B");
}
}
/**
*关键字 final --- 修饰变量时一次赋值不能被修改 修饰类的时候该类不能被继承(太监类)、修饰方法时不能被重写但是可以重载
**/
class TestFinal{
//final修饰的成员变量没有默认值
//一次赋值不能被修改(赋值方法一)
final int num2 =19;
//一次赋值不能被修改(赋值方法二)
final float num3;
TestFinal(){//不写访问修饰符
num3 = 10f;
}
final void fun1(){
System.out.println("TestFinal final function fun1 test");
}
//fun1重载
final void fun1(int num){
System.out.println("TestFinal final function fun1 reload test");
}
//fun1重载
void fun1(int num1,int num2){
System.out.println("TestFinal nomal function fun1 reload test");
}
//fun1重载
private final void fun1(int num,int num2, int num3){
System.out.println("TestFinal final function fun1 reload test");
}
}
final class TestExtFinal extends TestFinal{//可以把修饰TestExtFinal 类的 final 删掉
/*
//不能重写父类方法
final void fun1(){
System.out.println("TestExtFinal extends TestFinal final function's fun1 test");
}
*/
//重写父类方法
void fun1(int num1,int num2){
System.out.println("TestExtFinal extends TestFinal nomal function fun1 rewrite test");
}
final void fun2(){
System.out.println("TestExtFinal final function's fun2 test");
}
}
class Pair<T>{
private final T first;
private final T second;
public Pair(T first ,T second){
this.first = first;
this.second = second;
}
public T first(){
return first;
}
public T second(){
return second;
}
public List<String> stringList(){
return Arrays.asList(String.valueOf(first),String.valueOf(second));
}
}
/**
*关键字 abstract --- 修饰类时不一定有抽象方法，但是有抽象方法的类一定是抽象类，不能修饰变量
*抽象类允许有普通方法和变量 抽象方法不能有方法体且它的实现类必须的实现它的所有抽象方法
*子类只能继承一个抽象类(父类)
**/
abstract class AbsClass{
String str;
//abstract int num;
//抽象方法
abstract void fun1();
//抽象方法
abstract void fun2();
//普通方法
void fun3(){
System.out.println("nomal function fun3");
}
//普通方法
void fun4(){
System.out.println("nomal function fun4");
}
}
class ExtAbsClass1 extends AbsClass{
void fun1(){
System.out.println("Extends abstract class AbsClass's abstract Function fun1");
}
void fun2(){}
//重写抽象类的fun4方法
void fun4(){
System.out.println("Extends abstract class AbsClass's nomal function fun4");
}
}
abstract class AbsSonClass extends AbsClass{
abstract void fun5();
}
class ExtAbsClass2 extends AbsSonClass{
void fun1(){
System.out.println("Extends abstract class AbsClass's abstract Function fun1");
}
void fun2(){}
void fun5(){}
//重写抽象类的fun4方法
void fun4(){
System.out.println("Extends abstract class AbsClass's nomal function fun4");
}
}
/**
*关键字 interface --- 只能修饰类 接口的方法不能有实现体，子类可以实现多个接口， private protected static 不能用来修饰接口
**/
interface Infc{
public static final int num1 = 0;//public static final 三个顺序可以交换 也可以 写一个 写两个 或不写（默认为 public static final 类型）
void fun1();
}
class ClsIplIntrfc implements Infc{
public void fun1(){
System.out.println("实现接口的方法");
}
void fun2(){
System.out.println("zxfonline");
}
void fun3(){
this.fun2();
}
}
|
