java知识点总结

最新推荐文章于 2024-06-27 14:14:04 发布

lw371496536

最新推荐文章于 2024-06-27 14:14:04 发布

阅读量804

点赞数

分类专栏： java基础/j2se 文章标签： java thread string class exception byte

java基础/j2se 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

1、JAVA 标识符：只能由大小写字母、数学、下划线和$符号组成，不能以数字开头； JAVA 标识符是区别大小写的；

2、有 8 种基本数据类型: byte 8 short 16 char 16 int 32 long 64 float 32 double 64 boolean 1float f1=2.345f; double d1=234.43d; double d2=455.234; long l1=345534349l; 关于类型转换（除 boolean 外，其它类型可以混合运算）的原则是：范围小的变成范围大的，精度小的转换成精度大的；分强制类型转换和自动转换，以下转换是系统自动完成的，称自动类型转换，不会损失精度原则：大的对小的取余数，若是符点转换成整型，则舍会去小数点，若超过仍然继续上述过程。 byte ->short int long float double short ->int long float double char ->int long float double int ->long float double long->float double float->double int x=256; byte y=(byte)x; double x1=1.234,x2=266.345; byte m=(byte)x1; byte n=(byte)x2;

3、const goto 是 JAVA 预留保留字，目前没用到；

4、//行注释 /* */块注释 /** */文档注释；

5、了简单以下转义字符意义 \ddd \uxxxx \’ \’’ \\ \r \n \f \t \b

6、运算符逻辑运算符！ && || 逻辑非逻辑与逻辑或关系运算符 = = != < > >= <= 算术运算符 + - * / % ++ -赋值=和复合赋值语句条件运算符布尔表达式？ ture 的结果：false 的结果位运算符 &按位或 |按位与 ^按位异或 ~取反 <<左移，移出左边界的数据扔掉 byte a=15 a=a<<3 (120) 实际上满足 a<<n=a*2n >>带符号右移，左边空出位填符号 int a=8 ; a>>2 即 00000000 00000000 00000000 00001000 00000000 00000000 00000000 00000010 101100>>1 110110 >>>无符号右移，左边空出的位填 0

7、八进制必须以 0 开头如，0123（表示十进制 83）、-0123（表示十进制数-83）十六进制必须以 0X 或 0x 开头，如 0xb01e 0x25

8、JAVA 数组 int[] array[] ,二维数组声明，能通过但是不建议用;int[] [] array; int array[][]; int [] arr;=new int[5];构造数组必须指明长度（声明+构造） for(int i=0<i<5;i++) {arr[i]=i;} int [][] a=new inta[2][2]; a={{1,2},{3,4}};

9、String String str=”hello”; String s=new String(“abcd”); String 类的中方法： charAt,compareTo,compareToIgnoreCase,concat,length,indexOf(char c),substring,replace,trim,toLowerCase,toUpperCase，上述均为方法

10、类的修饰符有四种：默认访问：指类在声明时其前没有任何修饰符，是包级访问，们能被同一包中的类看到； public:所有包的所有类都可以访问该类； abstract :抽象类中至少有一个不能实现的现象方法，其中的抽象方法只有函数原型，没有实现（包括空的实现），故该类不能被实例化，该类在其子类中必须被重写； final: 最终类，不能被继续，即不能有子类；

11、类是对象的模板；Foo aa=new Foo();创建了类对象 aa,实例化之；

12、创建一个类对象步骤：创建类，声明一个对象类型的变量，使用 new 分配内存空间；

13、一个类可以有多个构造函数，具有相同的方法名（类名），在此编译阶段，编译器会根据参数个数和参数类型确定调用哪个构造函数（不能根据参数返回值）；

14、静态变量和静态方法可以直接用类名.静态变量或类名.静态方法名()来调用；

15、JAVA 访问成员变量及成员方法的访问权限五种： public: protected: private: 自己的类自己的类自己的类其子类其子类同一个包中的类不同包中的类其它还有的修饰变量或方法的修饰符：默认修饰符：成员变量或成员方法只能在自己的类及该类同一个包下的类访问 static: 被修饰的成员变量和成员方法都属于类，不属于具体实例，因此只需要用类名.静态变量或类名.静态方法名（）调用即可； final: 在整个程序执行中只允许赋值一次； transient: 只用来修饰非静态的成员变量； volatile，只能修饰成员变量； abstract: 抽象方法，其中没有定义具体的实现；

16、类的访问控制符有 public 和默认（前者可以为该类所在的包中任何代码访问，还可被其它包中的代码访问；而后者只能被该类所在同一个包的代码访问）类的成员访问控制修饰符有四种，相应的包对应不同的访问权限； public protected private 默认包内包内及子类类内的方法包内可见包外

17、访问超类的成员方法和变量用 super.方法名或变量名;

18、重载和重写不一样：重载指同一个类中的两个或多个地方可以共享一个相同的名称，只要它们的参数不同即可（是实现多态的方法之一），参数是决定哪个重载方法被调用；重写是子类在继承了超类方法后，需要修改超类的方法以满足自己的要求，重写要求超类中方法的修饰符不能为 private，因为 private 访问权限不出当前类；

19、final 定义变量，表示只能赋值一次，final 修饰方法表示该类不能被重写，final 修饰类时表示该类不能派生子类；

20、静态变量和静态方法属于类，调用时类名.静态 XX；而实例变量属于实例，在一个实例被创建和初始化时，属于这个实例的变量已经被保存在内存中；类中的静态方法不能访问成员变量；

21、接口是特殊的抽象类；接口中只能包含抽象方法和常量，不能有变量初始化块和构造函数；接口是可以多继承的； [public] interface 接口名 //public 修饰的接口可被包中的接口或类访问，否则只能[被包内接口或类访问 {常量抽象方法} 接口实现：修饰符 class XXX implements YYY {//必须提供所有抽象方法的实现，接口中定义的量不能再次被赋值} ，因为接口内的方法隐含是公有的和抽象的(即 public 和 abstract 不用写)，所以它们不能标识为 final native 或 strictfp，在方法声明中也可以不写 public 或 abstract，但是该方法还是公有的和抽象的；

22、抽象类可以实现接口，只要抽象类中有抽象方法即可；

23、内部类：指一个类嵌套在另一上类中，同时这个内部类是外部类的一个成员；class example16 { int a ; void print() { System.out.println("a="+a); }class example16_1 { int b; void print() { System.out.println("a="+a);//可在内部类中直接访问所属的外部成员变量（需声明是 final 类可在内部类中直接访问所属的外部成员变量（可在内部类中直接访问所属的外部成员变量型） System.out.println("b="+b);//可在内部类中直接存取其所在类私有成员变量可在内部类中直接存取其所在类私有成员变量 } } private String aa="这是一个方法内部类这是一个方法内部类"; 这是一个方法内部类void pprint() { final String t="这是一个局部变量局部变量前需加 final 这是一个局部变量";//局部变量前需加这是一个局部变量 class example16_2 { public void kk() { System.out.println(aa); System.out.println(t); } } example16_2 ee=new example16_2(); ee.kk();//内部类对象和调用内部类的成员方法内部类对象和调用内部类的成员方法 } }class example { example16 abc=new example16() { public void print() { System.out.println("这个子类重写了你类的方法这个子类重写了你类的方法"); 这个子类重写了你类的方法 } };//匿名内部类，这个子类需重写超类的方法，并且有个分号结尾；当然也可以定义自己的方法匿名内部类，这个子类需重写超类的方法，并且有个分号结尾；匿名内部类 void print1() { abc.print(); } }

注意：方法的局部变量存在栈中，而对象位于堆上；当方法结束时，栈结构被删该变量消失；但是定义在这个类中的内部类对象仍存活在堆上，所以内部类对象不能使用局部变量，除非这些局部变量被标识为最终的；

24、Exception 类和 Error 一起称为未检查异常有的：异常名称异常说明 ArithmeticException 除以 0 ArrayIndexOutOfBoundsException 数组下标出界 ArrayStroeException 数组元素值与类型不同 ClassCastException 强制类型转换异常 IllegalArgumentException 调用方法的参数非法 IllegalMonitorStateException 非法监控操作 IllegalStateException 环境或状态错误 IllegalThreadStateException 请求操作与线程不兼容 IndexOutOfBoundsException 索引越界 NullPointerException 非法使用空引用 NumberFomatException 字符串非法转换数字格式 SecurithEception 安全性 StringIndexOutBounds 字符串越界 UnsupportedOperationExcepiton 操作错误除 RuntimeExcepiton 以外的异常都是检查异常，本身不是错误； ClassNotFoundException CloneNotSupportedException IllegalAccessException InstantiationException InsterruptedException NotSuchFieldException NoSuchMethodException try //必须有 catch //catch 和 finally 有其一或两者都有； {} finally 当多个 catch 时，需将子类写在上面后写父类； throws 是声明异常，不处理它产生的异上，而是调用层次向上传递，谁调用就由谁处理； throw 是抛出异常，将它抛给一上级的调用者；

25、I/O 数据流分字节流(InputStream ,OutputStream 两个抽象类)和字符流(Reader, Writer 两个抽象类) 具体有：字节流： FileInputStream ByteArrayInputStream PipedInputStream BufferedInputStream FilterInputStream ObjectInputStream DataInputStream 文件字节输入/出流字节数组输入/出流管道输入/出流缓冲输入/出流过滤字节输入/出流对象输入/出流包含读取 JAVA 标准数据类型方法输入/出流 FileOutputStream ByteArrayOutputStream PipedOutputStream BufferedOutputStream FilterOutputStream ObjectOutputStream DataOutputStream包含 print()和 println()的输出流 26、文件类PrintStream

27、线程创建包括主纯种的创建、实现 Runnable 接口创建和 Thread 类的创建；实现 Runnable 类不需要是 Thread 的太可以运行，只需实例化一个 Thread 对象，并把它自己的引用当作参数传递给 Thread 的构造方法即可。

public class Runnable_Thread { public static void main(String[] args)

{

MyThread r =new MyThread();

Thread t=new Thread(r);

t.start();

for(int i=0;i<5;i++)

{ System.out.println("b"); }

} }

class MyThread implements Runnable {

int i;

public void run() {

while(true)

{

System.out.println("a"+i++); if(i==3) {break;} } } }

第二种方法，继承 thread 类

public class Main {

public static void main(String[] args)

{ MyThread t=new MyThread(); t.start(); for(int i=0;i<5;i++) { System.out.println("b"); } } class MyThread extends Thread { int i; public void run()

}{ while(true) { System.out.println("a"+i++); if(i==3) {break;} } } }

多线程代码示例：

public class Main { public static void main(String[] args) { MyThread1 t1=new MyThread1("First Thread"); t1.start(); MyThread2 t2=new MyThread2("Secon Thread"); t2.start(); MyThread3 t3=new MyThread3("Third Thread"); t3.start(); } } class MyThread1 extends Thread { String name; MyThread1(String threadname){name=threadname;} public void run() { try { for(int i=0;i<5;i++) { System.out.println(name+": "+i); Thread.sleep(1000); } }catch(Exception e) { System.out.println(name+"Exception"); } System.out.println(name+"Exit"); } } class MyThread2 extends Thread { String name; MyThread2(String threadname){name=threadname;}

public void run() { try { for(int i=0;i<5;i++) { System.out.println(name+": "+i); Thread.sleep(1000); } }catch(Exception e) { System.out.println(name+"Exception"); } System.out.println(name+"Exit"); } } class MyThread3 extends Thread { String name; MyThread3(String threadname){name=threadname;} public void run() { try { for(int i=0;i<5;i++) { System.out.println(name+": "+i); Thread.sleep(1000); } }catch(Exception e) { System.out.println(name+"Exception"); } System.out.println(name+"Exit"); } } 1.

29、线程状态转换图 a) 线程的实现有两种方式，一是继承 Thread 类，二是实现 Runnable 接口，但不管怎样，当我们 new 了这个对象后，线程就进入了初始状态; b) 当该对象调用了 start()方法，就进入可运行状态; c) 进入可运行状态后，当该对象被操作系统选中，获得 CPU 时间片就会进入运行状态; d) 进入运行状态后情况就比较复杂了

1、run()方法或 main()方法结束后，线程就进入终止状态;

2、当线程调用了自身的 sleep()方法或其他线程的 join()方法自身的方法，就会进入阻塞状态该状进入阻塞状态(该状方法或其他线程的方法进入阻塞状态停止当前线程，但并不释放所占有的资源)。当 sleep()结束或 join()结束后，该线程态即停止当前线程，但并不释放所占有的资源进入可运行状态，继续等待 OS 分配时间片; 进入可运行状态

3、线程调用了 yield()方法，意思是放弃当前获得的 CPU 时间片，回到可运行状态时间片，回到可运行状态，意思是放弃当前获得的这时与其他进程处于同等竞争状态，OS 有可能会接着又让这个进程进入运行状态;

4、当线程刚进入可运行状态(注意，还没运行)前，前发现将要调用的资源被 synchroniza(同步)，获取不到锁标记，将会立即进入锁池状态，等待获取锁标记(这时的锁池里也许已经有了其他线程在等待获取锁标记，这时它们处于队列状态，既先到先得)，一旦线程获得锁标记后，就转入可运行状态，等待 OS 分配 CPU 时间片;

5、当线程调用 wait()方法后会进入等待队列(进入这个状态会释放所占有的所有资源，这个状态会释放所占有的所有资源，这个状态会释放所占有的所有资源与阻塞状态不同)，是不能自动唤醒的，必须依靠其他线程调用 notify() 与阻塞状态不同进入这个状态后，其他线程调用方法才能被唤醒(由于 notify()只是唤醒一个线程，但我们由不能确定具体或 notifyAll()方法才能被唤醒方法才能被唤醒唤醒的是哪一个线程，也许我们需要唤醒的线程不能够被唤醒，因此在实际使用时，一般都用 notifyAll()方法，唤醒有所线程)，线程被唤醒后会进入锁池，等待获取锁标记。线程被唤醒后会进入锁池，线程被唤醒后会进入锁池等待获取锁标记。五种状态具体介绍：新状态：指线程实实例化后，但 start 方法还没有在该纯种上被调用进所处的状态（即仅仅实例化还没有执行 start（），它还不是一个执行线程；）可运行状态：start()方法启动后，线程就进入了可运行状态；就是准备好可以运行，但是还没有运行状态；还有从等待被阻塞睡眠监控挂起等待/被阻塞睡眠/监控挂起状态也可以进入可运行状态；等待被阻塞/睡眠监控/挂起运行状态：等待/被阻塞/睡眠/监控/挂起状态：死状态： sleep()强制线程进入睡眠状态，起到使线程停顿作用； join()方法使一个线程 1 跟在当前运行线程 2 后面运行； yield()方法使当前运行的线程回到可运行状态；让相同优先级的线程获得运行机会，称为让步方法，不过经常达不到让步的目的，因为只是让当前线程回到可运行状态，很可能运行的线程又是这一个；