1.在同一包中的类可以互相引用，无需import语句,非同包只能访问被申明为public的类，也就是缺省
的只能在同包中被访问
例如：
－－－－－－－－－－－－－－－－－－－
package com.cn;
class Test1
{
}
---------------
package com.cn;
class Test2
{
Test1 t1=new Test1();
}
－－－－－－－－－－－－－－－－－－－－－
package com.cn;
public class Test1
{
}
---------------
package com.net;
import java.com.cn.Test1;
class Test1
{
Test1 t3=new Test1();
}
－－－－－－－－－－－－－－－－－－－－－
2.java.lang包无需导入，会自动导入
3.能导入到底层就一定要导入到最底层－－－内存和效率考虑
4.final申明的类不能被继承，final什么的方法不能被覆盖，final申明的变量不能被修改
注意：一个类被申明为fianl后它的方法(不包括字段)会自动被设为final
/*
作者：kuikui
2007.03.25
功能：final申明的类不能被继承
*/
final class FinalClass
{
}
class FinalTest extends FinalClass //有误
{
}
－－－－－－－－－－－－－－－－－－－
class FinalMethod1
{
final public void output()
{
System.out.println("this is a final method1 test!");
}
}
class FinalMethod extends FinalMethod1
{
public void output()
{
System.out.println("this is a final method test!");//有误
}
public static void main(String [] args)
{
FinalMethod mt=new FinalMethod();
mt.output();
}
}
-------------------------------------------
/*
作者：kuikui
2007.03.25
功能：final申明的变量不能被修改
*/
class ConstantTest
{
static final double PI=3.1415926;
static double a=3.1415926;
public static void main(String [] args)
{
System.out.println(PI);
System.out.println(a);
a=1;
PI=2;//有误
System.out.println(a);
System.out.println(PI);
}
}
思考：java中为什么要有final关键字？提示：安全，效率
5.static 只能访问static方法和成员变量，而非static则可以反问static标识的
package teststatic;
//static申明的后,不能直接引用非static成员，需要在使用前构造
class Rectangle2
{
int w,l;
int perimter()
{
return(2*(w+l));
}
int area()
{
return w*l;
}
public static void main(String [] args)
{
Rectangle2 ret1=new Rectangle2();
Rectangle2 ret2=new Rectangle2();
ret1.w=2;
ret1.l=10;
System.out.println("the perimter of ret1 is = "+ret1.perimter());
System.out.println("the area ret1 is = "+ret1.area());
System.out.println("------------------");
ret2.w=20;
ret1.l=100;
System.out.println("the perimter of ret2 is = "+ret1.perimter());
System.out.println("the area of ret2 is = "+ret1.area());
}
}
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
/*
作者：kuikui
2007.03.24
功能：用面向过程的程序设计方法求矩形的周长和面积，主要是static的学习
注意：与面向对象的程序设计方法的区别（Rectangle2.java）
*/
package teststatic;
class Rectangle1
{
static int perimter(int w,int l)
{
return(2*(w+l));
}
static int area(int w,int l)
{
return w*l;
}
public static void main(String [] args)
{
System.out.println("the perimter is = "+Rectangle1.perimter(2,4));
System.out.println("the area is = "+Rectangle1.area(2,4));
}
}
－－－－－－－－－－－－－－－－－－－－－－－－－－－－
6.同一个包中的方法访问权限：
1)
/*
作者：kuikui
2007.03.25
功能：同一个包中的访问权限
*/
package com.mt;
class MethodResource
{
public void output1()
{
}
void output2()
{
}
private void output3()
{
}
protected void output4()
{
}
}
/*
作者：kuikui
2007.03.25
功能：同一个包中的访问权限
*/
package com.mt;
class MethodTest
{
public static void main(String [] args)
{
MethodResource m=new MethodResource();
m.output1();
m.output2();
m.output3();//有误
m.output4();
}
}
--------------------------------------------------------
2)同一个类中的访问权限
/*
作者：kuikui
2007.03.25
功能：同一个类中的访问权限:全部可以被访问
*/
public class MethodTest1
{
public void output1()
{
}
void output2()
{
}
private void output3()
{
}
protected void output4()
{
}
public static void main(String [] args)
{
MethodTest1 m=new MethodTest1();
m.output1();
m.output2();
m.output3();
m.output4();
}
}
----------------------------------------------------
3)子类中访问父类的方法访问权限
/*
作者：kuikui
2007.03.25
功能：子类中访问父类的访问权限:只有public方法和protected方法能被访问
*/
package test.tt;
public class Father
{
public void output1()
{
}
void output2()
{
}
private void output3()
{
}
protected void output4()
{
}
}
import test.tt.Father;
class SonTest extends Father
{
public static void main(String [] args)
{
SonTest son=new SonTest();
son.output1();
son.output2();//有误
son.output3();//有误
son.output4();
}
}
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
4) 不同包之间两个不同的类的访问权限:只能是public方法能被访问
7.类中所有的private和static方法自然就是final
8.构造方法、静态方法、私有方法、final方法不能被声明为抽象的方法
9.如果一个子类没有实现抽象基类中所有的抽象方法，则子类也成为一个抽象类
我们可以将一个没有任何抽象方法的类声明为abstract，避免由这个类产生任何的对象
注意：1)
abstract类中可以有具体的数据和具体的方法,即使没有abstract方法的类可以被申明为abstract
abstract class AbstractTest
{
String name;
public AbstractTest(String name)
{
name=name;
}
}
－－－－－－－－
2)一个abstract类不能构建这个类的对象，但是可以构建具体子类的对象。
abstract class AbstractPerson
{
int a=2;
String name;
public AbstractPerson(String name)
{
this.name=name;
}
}
class Kuikui extends AbstractPerson
{
String name;
public Kuikui(String name)
{
super("ll");
this.name=name;
}
public void out()
{
System.out.println(name);
}
public static void main(String [] args)
{
AbstactPerson p1=new AbstactPerson("kuikui");//is wrong
AbstractPerson p=new Kuikui("kuikui");
}
}
10.接口中所有的方法都是public abstract,在接口中声明方法时，不能使用native、static 、final 、
synchronized 、private 、protected等修饰符,和public类一样，public接口也必须定义在与接口同
名的文件中。实现接口的方法应该是申明为public,但是没有必要写public 因为接口中的方法会自动设为
public类型
注意：一个实现接口的类要实现其接口中所有方法。
接口不是类，不能用new去实例化接口
接口中的字段总时public static final的
/*
作者：kuikui
2007.03.25
功能：接口的简单应用
注意：实现接口的方法应该是申明为public
*/
package kuikui.interfacetest;
interf
