运算符:
1)算术运算符:+-*/%,++,–
2)关系运算符:>,=,<=,==,!=
3)逻辑运算符:&&,||,!
4)赋值运算符:=,+=,-=,*=,/=,%=
5)字符串连接运算符:+
6)三目/条件运算符:boolean?数1:数2
分支结构:有条件的执行某语句，并非每句必走
1)if结构:
2)if…else结构:
3)if…else if结构:
4)switch…case结构:
任何复杂的程序逻辑都可以通过三种结构来解决:
1)顺序结构:从上往下逐行执行，每句必走
2)分支结构:有条件的执行某语句，并非每句必走
3)循环结构:
线程重点：
线程内部按程序正常逻辑执行
线程与线程之间是抢占式执行
守护线程：
如何设置一个线程为守护线程？
在启动线程之前调用setDaemon方法即可。
守护线程与普通线程的区别？
当进程中只剩下守护线程时，所有线程强制终止，程序结束。
join 作用：用于线程同步
在哪里调用————————–阻塞当前线程
谁调用——————————–等待该线程结束
join方法可以让运行该方法的线程在该方法所属线程后面等待
直到方法所属线程运行完毕，才会解除阻塞
public class Thread_sleep2 {
public static void main(String[] args) {
Runnable d = new Runnable() {
public void run() {
for (int i = 0; i <= 100; i++) {
System.out.println(“已下载图片：” + i + “%”);
}
System.out.println(“下载完成！”);
}
};
Thread download = new Thread(d);
Runnable s = new Runnable() {
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(age<0 || age>100) {
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 <<= 8;
tem = data[i] & mask;
n |= tem;
}
System.out.println(n);
String gender = new String(data, 36, 10);
System.out.println(gender);
int mask1 = 0xff;
int tem1 = 0;
int n1 = 0;
for (int i = 46; i < 50; i++) {
n1 <<= 8;
tem1 = data[i] & mask1;
n1 |= tem1;
}
System.out.println(n1);
String hire = new String(data, 50, 20, “utf-8”);
System.out.println(hire);
jni
java native interface
Java本地调用
变量：
类型： 基本类型：整数 小数 字符 布尔
引用类型
命名规则： 变量名：由数字 字母 下划线 美元符号组成
不可以数字开头
支持中文，不建议用
最好见名知意
若是多单词命名，使用驼峰命名法 classStudent
不要使用java的关键字 保留字
初始化： (1) 先声明再初始化
(2) 声明同时初始化
注意：一个变量在它的作用域内只能声明一次，但是可以初始化n次
访问： 我们对变量的使用其实是访问内存的那个数
变量的使用必须符合它的类型
char 2个字节 字符型
都是正数 0-65535 0-2^16-1
1:采用unicode编码形式 每个字符都对应一个状态码 本质上是int类型
GBK 国标码
unicode UTF-8 国际编码
字符 必须写在单引号内，有且只有一个 不管是数字，字母，中文，符号
在java语言中，有一些特殊的符号没有办法体现出来：通过转义字符来显示
转义字符：\
换行符：\n
空格符：\t tab键
回车符：\r
整数直接量可以直接赋值给char 只要不超过其范围
字符串和数字 我们做拼接运算 字符串
字符和数字 做加法运算状态码
字符和字符串 做拼接运算 状态码不会转成相对应字符
数字和数字做加法运算
布尔类型 boolean 1个字节 true false 判断条件是否成立
数组的复制：arraycopy(原数组，原数组下标的位置，目标数组，目标数组的下标，复制的长度)
Arrays.copyof(数组名，长度) 扩容 缩容
String StringBuilder StringBuffer的区别？
不可修改 可以频繁修改字符串的内容 是线程安全的
packagestring;public classHome {public static voidmain(String[] args) {/** 输出一个字符串，然后若该字符串是一个整数，则转换为整数后输出乘以10后的结果 若是小数，则转换为一个小数后输出乘以5后的结果，若不是数字则输出”不是数字”
* 需要使用正则表达式进行判断*/String sss= “9.”;if (sss.matches(“^[0-9]+$”)) {
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程序设计中，能写成抽象的就绝不写成具体的。这样便于扩展，提高复用性。