Lesson3
包的概念:包与系统目录层次相对应的,只是用反斜杆分割”/”.
Package bao
Public class test {
Public static void main(String [] args){
System.out.println(“fff”);
}
}
要求有一个包名的目录
执行方式为:java bao/test 或java bao.test
Javac –d . test.java 可以自动生成目录.
Import ava.io.file
Import ava.io.*
导入其他类包,*是通配符,表示全部导入.
类的说明符 :
1. public
2. default(不加访问说明符时)
类的其他修饰符:
1. final
2. abstract抽象类
3. 同一包中的类互相访问,不用导入import,不通包必须导入.
Javac –d x.java
Javac –d y.java
如果编译的时候要注意顺序,如果x用到y,那么就要先编译y再编译x
如果怕麻烦,那就用javac –d *.java来统配编译
包外的类如果想被别的包访问,必须声明成public(公共的),这样才能被别的包访问.
4. final class 最终类,不能再派生子类,不能被继承.
5. 方法的说明符:
Public 公共
Protected保护
Default 默认
Private 私有
方法的其他修饰符:
static 静态的
final 最终不可改变
abstract抽象
native
synchronizde 同步方法
子类不想当抽象方法,就去实现父类的抽象方法,子类的实现的方法可以是空方法.
如果想设计一个类,找到这个类所有共性的,但是没有办法去了解这个类的个体里的方法体是什么样的,那么就可以设计成抽象类,比如做一个了人类,知道一些共性,但是无法了解每个人的名字和动作,就可以搞一个抽象的类,搞一些抽象的方法,然后通过子类继承来实现这些类.
1. class HelloWorld{
public native void as();
static {
System.loadLibrary("aaaa");
}
public static void main(String [] args ){
new HelloWorld().as();
}
}
2.编译
3.创建*.h 头文件用javah命令
Javah – jni HelloWorld
4.写方法#include<jni.h>
#include"HelloWorld"
#include<stdio.h>
JNIEXPORT void JNICALL
Java_HelloWorld_as(JNIEnv *, jobject);
{
printf("fsadfasd!/n");
return;
}
郁闷了,机器没有配c的环境,晕,再议~
垃圾回收问题:
在java.lang.Obiect有一个方法finalize,当垃圾回收器启动的时候,改方法被调用.
在java.lang.System.gc这个方法是强制执行垃圾回收器.
当java感到内存不足的时候垃圾回收器才运行,所以可以用gc强制执行.
接口的运用:
Interface 接口的定义语句
接口实现用: implements
Interface Spotr{
Void run();
Void jump();
}
Class tim implements Spotr {
Void run(){
System.out.println(“aa”);
};
Void jump(){
System.out.println(“bb”);
};
Public static void main(String [] args){
Tim t=new tim();
t.run();
t.jump();
}
}
接口里所有的方法都是public 和抽象的,所以要实现接口的方法体里的方法时,方法必须为public的.
要实现了接口后的类可以被实例化,那么就要重写接口里的所有方法
接口中可以有数据成员,声明为:public static final
一个接口可以继承另外一个接口
Java不容许类多继承,但接口可以多继承
实现接口人,和调用接口人,比如显卡和主板之间的接口,有显卡厂商去实现接口的功能,然后主板厂商调用接口的功能,其实调用的是实现类的功能.
|
|
|
接口定义一些方法,这些方法没有方法体,方法体由实现的人来定义 |
|
实现接口的功能,就是实现接口的人来实现这个接口里所有的方法的方法体 |
|
调用接口的方法体,直接调用的是接口类,而不是实现接口的类,就是上边指向的这个类 |
|
实现 |
|
调用接口,不是调用实现 |
要调用接口:要把接口的实现传给接口,然后在调用接口,用实现里的方法.
接口 A 实现 B
C调用
B 实现 A
C调用 A{
Public void setcard(A a){ 实现接口调用
This.a=a
}
B b=new B();
Setcard(b); 将接口的实现传给接口.
}
内部类
内部类可以访问外部所有成员,外部类可以控制内部类的可见性.
内部类和外部类可以有一样的方法名,因为内部类也可以直接拿到外部去定义.
内部类编译后的取名:
外部类名$内部类名.class
class outer{
class inner{
}
}
如果以类内部类被定义在一个方法里,那么这个内部类只能被这个方法来操作了.
通过outer.this.index来访问外部类的成员变量.
其他的类访问外部类的内部类,在外部类内定义方法:
Inner getinner(){
Return new Inner;
}
其他类调用:
Outer.Inner inner=new Outer.getinner();
inner.print();
其他类访问内部类,先用外部类产生内部类对象,然后其他类才可以调用内部类
Outer.Inner inner=Outer.new Inner();
静态方法不能调用非静态成员.
在一个方法中声明一个类,那么这个方法的参数和这个方法里的成员变量都要声明为final.(是需要在内部访问的时候才声明为final的).
这个为类继承带内部类的方法,内部类用super实例化.
class car{
class lun{
void ce(){
System.out.println("aaaa");
}
}
}
class pp extends car.lun{
pp(car ca){
ca.super();为了可以实例化内部类.
}
public static void main (String [] args){
car a=new car();
pp x=new pp(a);
x.ce();
}
}
内部类实现接口:
interface Animal{
void eat();
void sleep();
}
class Zoo {
class tiger implements Animal{
public void eat(){
System.out.println("eat");
}
public void sleep(){
System.out.println("sleep");
}
}
/*Animal getAnimal(){
return new tiger();//通过接口的实现去实现接口
}*/
Animal getAnimal(){
return new Animal(){//在这里直接实现接口
public void eat(){
System.out.println("eat");
}
public void sleep(){
System.out.println("sleep");//这是匿名的内部类
}
};
}
}
class test{
public static void main(String [] args){
Zoo z=new Zoo();
Animal an=z.getAnimal();
an.eat();
an.sleep();
}
}
异常处理:
Try{异常代码}catch(Exception e){捕获后执行的代码}finally{肯定会执行的代码}
很简单,好像没有什么可说的.
看一下api的异常.
程序编写错误,水平问题,这类错误不需要捕获的.
80
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
