如何看懂JAVA语言

运算符:

1)算术运算符:+-*/%,++,--

2)关系运算符:>,=,

Runnable d = new Runnable() {

public void run() {

for (int i = 0; i

public void run() {

System.out.println("等待图片下载完毕");

try {

download.join();

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("图片已显示");

}

};

Thread show = new Thread(s);

download.start();

show.start();

}

}

阻塞方法有哪些？

-------------------------------------------

java.lang.Object

继承者 java.util.Scanner

nextLine

public String nextLine()

-------------------------------------------

java.lang.Object

继承者 java.net.ServerSocket

accept

public Socket accept()

throws IOException

补充：trim()去除字符串两端的空白字符，ASCII表0-32均为空白字符，典型的有空格 回车 tab键。

线程：

线程与进程的区别？

进程  与  线程划分的尺度不同

进程：　不同进程不共享内存空间

线程：　不同线程共享内存空间

注意：　并发运行并不是同时运行

定义线程的两种方法：

1：继承Thread类

2：实现Runnable接口

第二种方法将定义线程任务与创建线程分开，达到解耦目的，体现了面向接口编程思想。

通过匿名内部类实现Runnable接口的方法创建线程demo：

public class Thread_sleep2 {

public static void main(String[] args) {

Runnable myclock = new Runnable() {

public void run() {

// 此处定义线程任务

}

};

Thread t = new Thread(myclock, "线程"); //创建线程

t.start();

}

}

线程的五大状态：

若干易混点：

①处于就绪状态的线程一定立即运行run方法吗？

答： 处于就绪状态的线程并不一定立即运行run()方法，线程还必须同其他线程竞争CPU时间，只有获得CPU时间才可以运行线程。

异常：

异常的分类：三类

Error

Checked Exception

RuntimeException

异常类的继承体系：

java.lang.Object

|——java.lang.Throwable

|——java.lang.Exception

|——java.lang.RuntimeException

java.lang.Object

|——java.lang.Throwable

|——java.lang.Error

如何使用自定义异常？

------------------------步骤一：定义异常类----------------------

第一步：  继承Exception

第二步：  生成序例化接口的版本号

第三步：  构建构造器

------------------------步骤二：定义对象类----------------------

throw自定义异常类对象，并使用throws关键字抛出待捕捉

------------------------步骤三：定义测试类----------------------

当调用有抛出异常类对象的方法时，需要捕捉该异常并处理

以下为demo代码演示：

package my_exception_demo;

public class MyException extends Exception{

/**

*

*/

private static final long serialVersionUID = 1L;

public MyException() {

super();

// TODO Auto-generated constructor stub

}

public MyException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {

super(message, cause, enableSuppression, writableStackTrace);

// TODO Auto-generated constructor stub

}

public MyException(String message, Throwable cause) {

super(message, cause);

// TODO Auto-generated constructor stub

}

public MyException(String message) {

super(message);

// TODO Auto-generated constructor stub

}

public MyException(Throwable cause) {

super(cause);

// TODO Auto-generated constructor stub

}

}

package my_exception_demo;

public class Person {

private int age;

public int getAge() {

return age;

}

public void setAge(int age) throws MyException{

if(age100) {

throw new MyException("年龄输入非法");

}

this.age = age;

}

}

package my_exception_demo;

public class Test {

public static void main(String[] args) {

System.out.println("程序开始了");

Person person=new Person();

try {

person.setAge(-5);

} catch (MyException e) {

e.printStackTrace();

System.out.println(e.getMessage());

}

System.out.println("程序结束了");

}

}

异常面试题：

try-catch-finally中finally代码块中代码必须执行

程序输出结果：

数组下标越界

空指针异常

3,3,3

1 packagemy_exception_demo;2

3 public classTest {4 public static voidmain(String[] args) {5 System.out.println(dosome("")+","+dosome(null)+","+dosome("1"));6 }7 public static intdosome(String str) {8 try{9 int i=str.charAt(0)-'1';10 returni;11 } catch(NullPointerException e) {12 System.out.println("空指针异常");13 return 1;14 } catch(IndexOutOfBoundsException e) {15 System.out.println("数组下标越界");16 return 2;17 } finally{18 return 3;19 }20

21 }22 }

Socket网络编程基本步骤：

Socket交互的基本流程？客户端和服务端均通过Socket实例完成通讯

1 packagesocket;2

3 importjava.io.IOException;4 importjava.net.ServerSocket;5 importjava.net.Socket;6 /**

7 * 服务器端如何获得Socket对象？8 * 通过ServerSocket中的accept()方法来获得Socket对象9 *@authorsoft0110 *11 */

12 public classMyServer {13

14 privateServerSocket server;15

16 public MyServer() throwsIOException {17 server = new ServerSocket(8088);18 }19

20 public void start() throwsIOException {21 Socket socket = server.accept();//阻塞方法 等待客户端连接

22 }23

24 public static void main(String[] args) throwsIOException {25 MyServer server = newMyServer();26 server.start();27 }28

29 }

1 packagesocket;2

3 importjava.io.IOException;4 importjava.net.Socket;5 importjava.net.UnknownHostException;6 /**

7 * 客户端如何获得Socket对象？8 * 直接new Socket对象，传入IP地址 端口号PORT9 *@authorsoft0110 *11 */

12 public classMyClient {13

14 privateSocket socket;15

16 public MyClient() throwsUnknownHostException, IOException {17 socket = new Socket( //服务端创建Socket实例完成后，客户端完成创建

18 "localhost", //127.0.0.1 本地机

19 8088); //端口号

20 }21

22 public voidstart() {23

24 }25

26 public static void main(String[] args) throwsUnknownHostException, IOException {27 MyClient client = newMyClient();28 client.start();29 }30

31 }

raf 的使用：

RandomAccessFile类的使用，该类不属于InputStream、OutputStream/Writer、Reader体系，不属于流类。其直接继承自Object

通过seek()方法可定位文件指针，该功能能反复读取任意位置的文本，并能覆盖任意位置的字符，是不是很吊啊。。。

RandomAccessFile raf = new RandomAccessFile("user.dat", "rw");

byte[] data = new byte[70];

raf.read(data);

String name = new String(data, 0, 32, "utf-8").trim();

System.out.println(name);

int mask = 0xff;

int tem = 0;

int n = 0;

for (int i = 32; i < 36; i++) {

n

System.out.println(Integer.parseInt(sss)* 10);

}else if (sss.matches("^[0-9]*\\.[0-9]*$")) {

System.out.println(Float.parseFloat(sss)* 5);

}else{

System.out.println("字符串");

}

}

}

==值比较

equal() toString();自己可以根据需要重写这两个方法

相对路径：

类所属项目的根目录

写一段程序完成1+2+3+4+...+100 不得使用for while 关键字

1块钱一瓶，3个瓶盖可以换一瓶 2个空瓶可以换一瓶 20快可以呵几瓶

递归：想要看懂递归抓条件判断

File 文件类不能对文件数据进行操作

RandomAccessFile 能对文件数据进行操作 实例对象使用完成之后close释放系统资源

FileFilter 接口 需要重写accept方法 过滤器

递归：

第一步：if判断递归结束条件 return返回

第二步：执行方法体

第三步：重复调用本方法

File类

不管文件存在与否，都可以new对象，通过对象可以判断当前目录是否存在指定文件或目录

File对象不能操作文件本身的数据！！！

磁盘操作电磁转换 速度为毫秒级

CPU速度为纳秒级别 速度不匹配，所以出现了内存

jdk1.5出现的自动拆装箱特性：

包装类和基本数据类型直接转换

String类：

几个快捷键的使用

事件监听：

两步走：

1、创建监听器

2、注册监听器到被监听对象上

package fdhs;

import java.awt.Frame;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import javax.swing.JPanel;

public class Sfdgdfg extends JPanel{

public void action() {

Frame fr=new Frame();

fr.setSize(400, 700);

fr.setVisible(true);

JPanel j=new JPanel();

fr.add(j);

MouseAdapter l=new MouseAdapter() {

@Override

public void mouseClicked(MouseEvent e) {

// TODO Auto-generated method stub

System.out.println("鼠标单击了");

}

@Override

public void mouseMoved(MouseEvent e) {

// TODO Auto-generated method stub

System.out.println("鼠标移动了");

}

};

fr.addMouseListener(l);

fr.addMouseMotionListener(l);

}

public static void main(String[] args) {

Sfdgdfg world=new Sfdgdfg();

world.action();

}

}

定时触发：

run()方法重写定时任务，代码如下：

packagefdhs;importjava.util.Timer;importjava.util.TimerTask;public classSfdgdfg {public static voidmain(String[] args) {

Timer timer=newTimer();

timer.schedule(newTimerTask() {

@Overridepublic voidrun() {//TODO Auto-generated method stub

System.out.println("我每个1秒出现一次哦");

}

},10, 1000);

}

}

接口：

①接口是一种数据类型

②由interface定义，由implements实现

③接口中只包含常量和抽象方法

④接口是需要被实现的，相当于继承的，必须重写接口中的所有抽象方法

⑤一个类可以实现多个接口，用逗号隔开。若有继承，有实现，继承放在前面

⑥接口不能被实例化

⑦接口可以继承接口

超类：所有派生类中所共有的行为跟属性

接口：部分派生类所共有的行为

派生类：派生类中所特有的属性跟行为

反射：

通常与接口 配置文件(参数信息) Tomcat(或者是各种框架)配合使用

package ddddd;

public class Df {

public static void main(String[] args)

throws ClassNotFoundException, InstantiationException, IllegalAccessException {

createNewClass();

}

public static void createNewClass() throws ClassNotFoundException, InstantiationException, IllegalAccessException {

/*

* 三步走

* 创建此 Class 对象所表示的类的一个新实例。如同用一个带有一个空参数列表的 new 表达式实例化该类。如果该类尚未初始化，则初始化这个类。

*/

// ①包名.类名

String className = "ddddd.A";

// ②创建Class对象

Class clazz = Class.forName(className);

// ③产生该类对象

Object obj = clazz.newInstance();

if (obj instanceof A) {

A a = (A) obj;

System.out.println(a.x);

}

}

}

class A {

int x;

int y;

A() {

this.x = 4;

this.y = 2;

System.out.println("A run...");

}

}

造型：

向上造型能造成什么？超类或者接口都可以

为什么要进行类型转换？

向上造型之后，能点出来的东西变少了，所以要进行向下造型。

小转大，自动类型转换(没有任何问题)

大转小，强制类型转换(可能会有错误)

该引用指向的对象是否是该类型

该引用指向的对象是否实现了该接口

能点出来什么东西，看引用

具体执行哪个方法，看对象

若干问题：

①

java关于流的问题？

BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));

BufferedReader和InputStreamReader都是属于Reader类的子类，两者也没有父子关系，为什么可以这样code？

答：

Java里，创建对象用的“new”表达式是一个表达式，可以用在任何可以接受表达式而且类型匹配的地方。

Java的类可以提供多重载(overload)版本的构造器。

BufferedReader(Reader in)

所以在new BufferedReader(xxx)的时候，xxx只要是一个类型跟 java.io.Reader 匹配的表达式即可。

例如说，既可以这样写：

Reader inner = new InputStreamReader(System.in);

BufferedReader br = new BufferedReader(inner);

也可以省略那个inner局部变量，而直接把inner右手边的表达式内容直接替换到参数位置上：

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

②this 和super

this指代当前对象，常用于构造函数中：

class A

{

int x;

int y;

A(int x,int y){

this.x=x;

this.y=y;

}

}

super指代当前对象的超类对象，常用于在派生类的构造方法中对超类成员进行初始化：

class A extends B

{

int x;

int y;

A(int x,int y){

super(1,2);

this.x=x;

this.y=y;

}

}

class B

{

int a;

int b;

B(int a,int b){

this.a=a;

this.b=b;

}

}

③String类型如何比较相等？

String对象一旦创建不可变

从jdk1.7开始，存放在堆内存的常量池中

packagefdhs;public classSfdgdfg {public static voidmain(String[] args) {

String s1="12";

String s2="12";

System.out.println(s1==s2);//true

}

}

关于String s1=new String("12");创建几个对象的问题：2个

package fdhs;

public class Sfdgdfg {

public static void main(String[] args) {

String s1=new String("12");

System.out.println(s1);//首先在池内找，找到？不创建string对象，否则创建， 这样就一个string对象

//遇到new运算符号了，在内存上创建string对象，并将其返回给s1，又一个对象

}

}

基本数据类型比较相等直接画等号

String类型比较相等用equals,示例代码：

String c1="aaaaaaa";

String c2="aaaaaaa";

boolean boo=c1.equals(c2);

System.out.println(boo);

④

java.lang包，这个lang是language的意思吗？

Package java.lang Description

Provides classes that are fundamental to the design of the Java programming language.

答：是

⑤ 重要原则：java程序设计中，能写成抽象的就绝不写成具体的。这样便于扩展，提高复用性。