|
Un resumen .final
1.final modificado Clase: representa la clase no se puede heredar
final no modificado interfaz de interfaz de
métodos de modificación 2.final: indica que el método no puede ser anulado por clase (es decir, la subclase última clase padre puede anular puede ser heredada)
final de constructor no modificado
3.final propiedades de campo modificación: que no se pueden modificar los valores de característica primero inicializadas
propiedades finales se pueden inicializar directamente en el constructor o inicialización
si el atributo se inicializa directamente, el valor de otras funciones (incluyendo constructores) no se puede modificar
4. función de modificación final parámetro de
la función argumento no se puede modificar
las variables locales de la función modificada 5.final
no pueden ser modificados después de la primera variable local se inicializa
Hola public void () {
String nombre final;
name = "Hola"; OK //
nombre = "Hola"; // error
}
Use sentido final:
La razón para utilizar el método final, puede estar fuera de consideración por dos razones. Primer método está "bloqueado" para evitar cualquier clase que hereda de cambiar su significado original. Al diseñar el programa. Si desea un método de comportamiento se mantiene sin cambios durante la herencia y no se pueden sobrescribir o reescrito, se puede tomar este enfoque.
El método adoptado segunda razón final es la eficiencia de la ejecución del programa. Después de un método se establece en definitiva, el compilador puede poner todas las llamadas a métodos que se colocan "incrustado" en la llamada.
Dos resumen .static
1.static función miembro modificado: Esta función no se puede utilizar a este miembro objeto
no puede ser modificado constructores estáticos
función parámetros estáticos no pueden ser modificados
variable de miembro local estática no se modifica
2.Static campo miembro de modificaciones
cuando se carga la clase cuando una máquina virtual, primeros campos miembros estáticos se inicializan en la declaración de campo de orden
3.static bloque de instrucciones modificado
cuando la clase se carga VM, con el fin declaración tiene que inicializar campos miembros estáticos y bloque de sentencias estáticas
Los campos estáticos se modifican y el método sólo pertenecen a la clase, todos los objetos compartidos.
No se puede utilizar campos no estáticos en la función miembro estática y el bloque de sentencias modificado.
Las variables globales no pueden ser definidas directamente en Java, se logra a través de la estática
no es const en Java, no definir directamente constantes, se consigue por static final
importar java.util. *;
/ **
* @ pantallas: java关键字的复习
* @ auther: http://www.javaweb.cc
* @ versión: lv 1.0.0
@time: 01/31/2010
** /
public class Test {
public static void main (args String []) {
/ ******************** estática的使用***************** **** /
/ *
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 ();
* /
/ ************************************************* **** /
/ ******************* uso 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();
}
}
|
