//数组申明的几种方式,我写的这几个破类 为什么数组只能在语句块中申明？
public class Array
{
static int[] array1;
{
array1=new int[]{1,1,1,1,1};
int[] array2={2,2,2,2,2};
int[] array3=new int[5];
for(int n=0;n<array3.length;n++)
{
array3[n]=3;
System.out.println("array3:"+array3[n]+" ");
}
int[][] array4 ;
array4=new int[][]{{1,1,1},{2,2},{3}};
int[][]array5={{1,1,1},{2,2},{3}};
int[][] array6=new int[3][3] ;
for(int i=0;i<array6.length;i++)
for(int j=0;j<array6[i].length;j++)
{
array6[i][j]=(i+j)*2;
System.out.println("array6: "+array6[i][j]);
}
}
}
//变量
class Variable
{
{
byte variable1=1; //一个字节
short variable2=2; //二个字节
int variable3=4; //四个字节
long variable4=8L; //八个字节
char variable5=2; //二个字节 无符号
char variable6='a';
float variable7=4.4F; //四个字节 小数常量默认为double类型，如果要赋浮点型就要加f
double variable8=8.8;
variable1+=6;//八个字节
//variable1=variable1+1;//byte类型参与运算后自动专为int类型不能赋给byte
System.out.println("variable1="+variable1);
}
}
class Test
{
public static void main(String[] args)
{
Array ay=new Array();
//ay.toString();
Variable va=new Variable();
System.out.println("array1="+Array.array1[4]);
System.out.print("va equal ay ? "+va.equals(ay));
}
}
/*结果：array3:3
array3:3
array3:3
array3:3
array3:3
array6: 0
array6: 2
array6: 4
array6: 2
array6: 4
array6: 6
array6: 4
array6: 6
array6: 8
variable1=7
array1=1
va equal ay ? false
*/
***********************************************************************
接口：
interface Lunzi//缺省接口只能在同一个包中进行访问
{
int heavy=20;//接口中的数据成语都是public static final
public abstract void run();//共有的抽象
void daqi();//接口中所有的方法默认都是共有的抽象的
}
interface Cheshen
{
int longs=5;
void touguang();
void touqi();
}
class Dazhong implements Cheshen,Lunzi //大众厂商生产车身和轮子
{
public void output()
{
System.out.println("轮子重量"+heavy+"车身长度"+longs );
}
public void run()
{
System.out.println("轮子转动正常");
}
public void daqi()
{
System.out.println("轮子充气良好");
}
public void touguang()
{
System.out.println("车身透光良好");
}
public void touqi()
{
System.out.println("车身透气性好");
}
}
class Cheban//车板安装车身和轮子
{
Lunzi lz;
Cheshen cs;
void setLunzi(Lunzi lz)//使用接口Lunzi安装轮子。
//这里传的参数看似Lunzi接口的一个实例,其实是大众的实例，
//因为最后将把大众的实例的引用传给LZ,接口是不能被实例化的。和任何抽象类一样。
{
this.lz=lz;
}
void setCheshen(Cheshen cs)
{
this.cs=cs;
}
void runcar()
{
lz.daqi();
lz.run();
cs.touguang();
cs.touqi();
System.out.println("呜呜~~~~~~~~");
}
public static void main(String[] args)
{
Dazhong dz=new Dazhong();
//Dazhong dz1=new Dazhong();
dz.output();
System.out.println("轮子重量="+dz.heavy+" or"+Lunzi.heavy+
"； 车身长度="+dz.longs+" or "+Cheshen.longs);//因为接口中的数据成员都是共有静态的
Cheban cb=new Cheban();
cb.setCheshen(dz);
cb.setLunzi(dz);//大众的实例的引用传给LZ
cb.runcar();
}
}
//运行结果：
/*轮子重量20车身长度5
轮子重量=20 or20； 车身长度=5 or 5
轮子充气良好
轮子转动正常
车身透光良好
车身透气性好
呜呜~~~~~~~~
*/
/**JAVA不允许类的多继承 但允许接口的多继承 类可以实现多个接口 也可以继承一个类同时实现多个接口；*/
/**************************内部类***********************/
/********************文件一：类的嵌套*********************/
/*class Outer
{
private static int index=100;//内部类可以访问外部类的私有变量
void text()
{
System.out.println("内部类调用外部类的方法");
}
void fn(final int a)//内部类的嵌套
{
final int b=0;//方法中的局部变量或参数如果需要被 方法中的内部类访问就必须声
//明为常量；
if(true)
{
class Middle
{
private int index=60;
class Inner
{
private int index=50;
void print()
{
text();
int index=30;
System.out.println("方法中的index值 : "+index);
System.out.println("Inner中成员变量index : "+this.index);
System.out.println("Middle.this.index : "+Middle.this.index);
System.out.println("Outer.this.index : "+Outer.this.index);
//a=5;
//b=6;
System.out.println("常量a="+a);
System.out.println("常量b="+b);
}
}
}
Middle md=new Middle(); //在语句块中定义的内部类其作用域只在块内。在语句块外// 不能实例化；
Middle.Inner in=md.new Inner();
in.print();
}
}
}
class Test
{
public static void main(String[] args)
{
Outer outer=new Outer();
outer.fn(1111);//通过方法调用方法中的内部类
}
}
/*运行结果
内部类调用外部类的方法
方法中的index值 : 30
Inner中成员变量index : 50
Middle.this.index : 60
Outer.this.index : 100
常量a=1111
常量b=0
*/
/**********************内部类文件二***********************/
class Outer
{
private static int index=100;//内部类可以访问外部类的私有变量还可以用abstract final
void text()
{
System.out.println("内部类调用外部类的方法");
}
private static class Inner//内部类可以有和成员方法一样的访问控制符当其被声明为静态的时候 就切断了与外部类的对象的联系，不能再访问外部类中的非静态成员，
{
private int index=50;
void print()
{
int index=30;
System.out.println(index);
System.out.println(this.index);
System.out.println(Outer.index);
//Outer.this.text();//text为非静态方法所以不能被静态内部类访问
}
static void print2()
{
System.out.println("只有顶层类和静态内部类才可以有静态方法");
//System.out.println(this.index);不能在静态环境中使用this 因为静态成员属于类 与类的对象无关；
System.out.println(Outer.index);
}
}
void print()
{
Inner inner=new Inner();//在外部类的方法中实例化内部类
inner.print();
}
Inner getInner()
{
return new Inner();//外部类的方法中实例化并返回一个内部类对象
}
public static void main(String[] args)
{
Outer outer=new Outer();
outer.print();
Inner inner1=outer.getInner();//main在Outer中此时Inner可见所以不用Outer.Inner
inner1.print();
Inner.print2();
//Inner inner2=outer.new Inner();//此时Inner可见，但还是不能直接new Inner(); 如果内部类被声明为静态的 此语句错误，因为内部类已经失去了与外部类对象的联系 即没有了 Outer.this
//inner2.print();
}
}
class Test
{
public static void main(String[] args)
{
//三种方法调用Inner类的print();
Outer outer=new Outer();//第一种
outer.print();
Outer.Inner inner1=outer.getInner();//第二种
inner1.print();
Outer.Inner inner2=outer.new Inner();//第三种 直接实例化，特殊语法：out.new 因为在创建内部类的时候需要外部类对象的一个引用因为外部类可能有多个对象，
inner2.print();
}
}
/*运行结果：
30
50
100
内部类调用外部类的方法
30
50
100
内部类调用外部类的方法
30
50
100
*/
/****继承内部类**/
class Car
{
class Wheel
{
}
}
class PlaneWheel extends Car.Wheel
{
PlaneWheel(Car car)
{
car.super();//特殊语法 建立内部类与指定外部类对象的联系；
}
public static void main(String[] args)
{
Car car=new Car();
//Car.Wheel wheel=car.new Wheel();
PlaneWheel pw=new PlaneWheel(car);
}
}
/*****用匿名的内部类 实现继承同时实现抽象类**/
class A
{
void fn1()
{
System.out.println("实现A的方法");
}
}
abstract class B
{
abstract void fn2();
}
class C extends A //用匿名的内部类 实现继承同时实现抽象类（相当于多继承）
{
B getB()
{
return new B()
{ //括号内为一个匿名的内部类用以在return语句结束之前实现抽象类
public void fn2()
{
System.out.println("实现了抽象类B的方法");
}
};//分号不能省 标志return的结束
}
}
class Test
{
static void method1(A a)//静态方法传递A实例的一个引用 以调用fn1()
{
a.fn1();
}
static void method2(B b)//静态方法传递B实例的一个引用 以调用fn2() 但B不能被实例化
{
b.fn2();
}
public static void main(String[] args)
{
C c=new C();//创建C的一个实例
A a=new A();
method1(c);//因为C继承自A所以C的实例是A的实例；可以在任何需要超类对象的地方用子类对象
method2(c.getB());
System.out.println("(c isInstanceOf A)"+(c instanceof A));//true
System.out.println("(a isInstanceOf C)"+(a instanceof C));//false
}
}
/****内部类 和匿名内部类实现接口*****/
interface Animal
{
void eat();
void sleep();
}
class Zoo
{
private class Tiger implements Animal
{
public void eat()
{
System.out.println("tiger eat");
}
public void sleep()
{
System.out.println("tiger sleep");
}
}
Animal getAnimal()
{
return new Tiger();
}
/*Animal getAnimal()
{
return new Animal()//匿名内部类实现接口。必须在返回对象之前即return语句的封号前；
{
public void eat()
{
System.out.println("animal eat");
}
public void sleep()
{
System.out.println("animal sleep");
}
};
}*/
}
class Test
{
public static void main(String[] args)
{
Zoo z=new Zoo();
Animal an=z.getAnimal();
an.eat();
an.sleep();
}
}
//一个类可以在继承的同时取实现接口，但如果他要继承的类和要实现的接口
//有同名的方法时 如果直接实现不好，所以用内部类实现接口；
interface Machine
{
void run();
}
class Person
{
void run()
{
System.out.println("run");
}
}
class Robot extends Person
{
private class MachineHeart implements Machine
{
public void run()
{
System.out.println("heart run");
}
}
void run()
{
super.run();
MachineHeart mheart=new MachineHeart();
mheart.run();
}
Machine getMachine()
{
return new MachineHeart();
}
}
class Test1
{
public static void main(String[] args)
{
Robot robot=new Robot();
robot.run();
Machine m=robot.getMachine();
robot.run();
}
}
posted on 2007-05-07 21:09
唐佚 阅读(109)
评论(0) 编辑 收藏