菜鸟学Java第二天 Java 中特殊关键字
ava class 中public、protected 、friendly、private的区别
1. 类（class）
可见性修饰符： public—在所有类中可见，在其他包中可以用import导入。
缺省—就是没有修饰符，在同一个包中的类中可见，在其他包中不能用import导入。
修饰符： final—终态类，表示该类不能被继承
abstract—抽象类，不能新建对象
2. 变量（variable）
Java中变量有两种，方法变量和字段变量
方法变量只能用一个修饰符：
final—表示常量，不能修改
下面是字段变量的修饰符
可见性修饰符：
public—在任何类中可见
protected—在子类中或同一个包中可见
private—只在本类中可见，子类中也不可见
缺省—在同一个包中可见，子类不在一个包中，子类中也不可见
修饰符：
static—静态变量，被类的所有实例共享
final—常量，定义后不能修改
*transient—告诉编译器，在类对象序列化的时候，此变量不需要持久保存
*volatile—指出可能有多个线程修改此变量，要求编译器优化以保证对此变量的修改能够被正
确的处理
这两带*的不是很常用，但也是Java的修饰符，我也不是很清楚
3.方法(method)
可见性修饰符：
public—在任何类中可见
protected—在子类中或同一个包中可见
private—只在本类中可见，子类中也不可见
缺省—在同一个包中可见，子类不在一个包中，子类中也不可见
修饰符：
static—静态方法，并不需要创建类的实例就可以访问静态方法
final—常方法，所有子类不能覆盖该方法，但可以重载
abstract—抽象方法，在抽象类中没有实现的方法
native—本地方法，参见Java Native Interface(JNI)
synchronized —在多线程中，synchronized方法调用时，其他所有方法不能调用该方法
3. 接口（interface）
可见性修饰符：
public—所有类中可见
缺省—同一个包中可见
接口中的变量总是需要定义为“ public static final 接口名称”，但可以不包含这些修饰符，编译器默认就是这样
接口中的方法只能使用public和abstract修饰符
修饰符的访问范围如下：
| 修饰符 | 类 |成员访求|构造方法|成员变量|局部变量|
| abstract 抽象的 | √ | √ | － | － | － |
| static 静态的 | － | √ | － | √ | － |
| public 公共的 | √ | √ | √ | √ | － |
| protected 受保护的 | | √ | √ | √ | － |
| private 私有的 | － | √ | √ | √ | － |
|synchronized 同步的 | － | √ | － | － | － |
| native 本地的 | － | √ | － | － | － |
| transient 暂时的 | － | － | － | √ | － |
| volatie 易失的 | － | － | － | √ | － |
| final 不要改变的 | √ | √ | － | √ | √ |
1.private :(妻子) 只有自己能用。
2.public :（J女）谁都可以用。
3.protected:(家里的钥匙)只有家人可以用。
4.friendly:(公共客厅) 你和别人合租房子，公共客厅就是friendly 。
在说明这四个关键字之前，我想就class之间的关系做一个简单的定义，对于继承自己的class，base class可以认为他们都是自己的子女，而对于和自己一个目录下的classes，认为都是自己的朋友。
-------------------------------------------------------------------------------
http://hi.baidu.com/zxfonline/blog/item/d0efbccb0308874df21fe789.html
java 关键字 static final abstract interface public private protected 和方法 重写 重载 等的用法
import java.util.*;
public class Test{
public static void main(String[] args){
ClsIplIntrfc cl = new ClsIplIntrfc();
cl.fun1();
cl.fun3();
}
}
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 语句块中不能有方法
}
//静态方法直接用--- 类名.方法名
static void doSm(){
System.out.println("static function sm of class B");
}
}
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 删掉
//重写父类方法
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 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 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();
}
}
