运算符:
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 package my_exception_demo; 2 3 public class Test { 4 public static void main(String[] args) { 5 System.out.println(dosome("")+","+dosome(null)+","+dosome("1")); 6 } 7 public static int dosome(String str) { 8 try { 9 int i=str.charAt(0)-'1'; 10 return i; 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 package socket; 2 3 import java.io.IOException; 4 import java.net.ServerSocket; 5 import java.net.Socket; 6 /** 7 * 服务器端如何获得Socket对象? 8 * 通过ServerSocket中的accept()方法来获得Socket对象 9 * @author soft01 10 * 11 */ 12 public class MyServer { 13 14 private ServerSocket server; 15 16 public MyServer() throws IOException { 17 server = new ServerSocket(8088); 18 } 19 20 public void start() throws IOException { 21 Socket socket = server.accept();//阻塞方法 等待客户端连接 22 } 23 24 public static void main(String[] args) throws IOException { 25 MyServer server = new MyServer(); 26 server.start(); 27 } 28 29 }
1 package socket; 2 3 import java.io.IOException; 4 import java.net.Socket; 5 import java.net.UnknownHostException; 6 /** 7 * 客户端如何获得Socket对象? 8 * 直接new Socket对象,传入IP地址 端口号PORT 9 * @author soft01 10 * 11 */ 12 public class MyClient { 13 14 private Socket socket; 15 16 public MyClient() throws UnknownHostException, IOException { 17 socket = new Socket( //服务端创建Socket实例完成后,客户端完成创建 18 "localhost", //127.0.0.1 本地机 19 8088); //端口号 20 } 21 22 public void start() { 23 24 } 25 26 public static void main(String[] args) throws UnknownHostException, IOException { 27 MyClient client = new MyClient(); 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语言中,有一些特殊的符号没有办法体现出来:通过转义字符来显示
转义字符:
换行符:
空格符: tab键
回车符:
整数直接量可以直接赋值给char 只要不超过其范围
字符串和数字 我们做拼接运算 字符串
字符和数字 做加法运算状态码
字符和字符串 做拼接运算 状态码不会转成相对应字符
数字和数字做加法运算
布尔类型 boolean 1个字节 true false 判断条件是否成立
数组的复制:arraycopy(原数组,原数组下标的位置,目标数组,目标数组的下标,复制的长度)
Arrays.copyof(数组名,长度) 扩容 缩容
String StringBuilder StringBuffer的区别?
不可修改 可以频繁修改字符串的内容 是线程安全的
package string; public class Home { public static void main(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()方法重写定时任务,代码如下:
package fdhs; import java.util.Timer; import java.util.TimerTask; public class Sfdgdfg { public static void main(String[] args) { Timer timer=new Timer(); timer.schedule(new TimerTask() { @Override public void run() { // 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)版本的构造器。
Java的 java.io.BufferedReader 里有一个这样的构造器:
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开始,存放在堆内存的常量池中
package fdhs; public class Sfdgdfg { public static void main(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);