正数:
源码:即对应的二进制
源码,反码,补码一样
负数:
反码 = 最高位之后全取反,最高位不变
补码 = 反码 + 1
float: 后面要加f
long: 后面要加 L 或 l
switch 根据jdk版本
1.6及以上版本支持string变量
switch常量值不能一样
switch能解决的问题,都可以用多重if都可以解决
但是反过来不可以
等值判断首选switch
switch只能执行等值判断问题
无特殊情况case 最后要break;
默认值default放在最后比较好
异常:if(input.hasNextInt()){}
循环结构:
while(条件表达式) 先判断 后执行
do while 无条件执行一次,然后再判断条件
变量在哪个大括号里面声明
作用域就在哪个大括号里面
string变量.equals(“y”)
System.exit(0); //正常退出程序
int random = (int)(Math.random()*1000);
//随机生成1000以内的整数
import java.util.Scanner;
Scanner input = new Scanner(System.in);
int x = input.nextInt();
//创建输入
数组一般和for循环一起使用
循环次数确定用for循环
for(; ; ;)可省表达式,分号不可省
过程:表达式1,表达式2正确则执行循环体,表达式3
break //跳出当前整个循环结构
与条件语句一起使用
continue; //跳过本次循环
与break区分开来
array //数组开辟连续的空间存数据
数组也有数据类型
数组元素的数据类型相同
int[] a; //声明数组,声明后长度固定
a = new int[5]; //给数组分配空间
a[0] = 8; //赋值
b = a; // 两个数组公用一个内存(浅拷贝)
// a 改变后 b 也是改变了,两个数组同时改变
a[0] = a[0]*10; //使用数组元素
数组作为参数传递,作为引用
可以作为引用参数改变值
也可以:
int[] a = new int[5]; //一次性分配空间
一个int类型4个字节
int[] a = {a,b,c,d}; //一次性赋值
//想要倒序就反过来输出
求最大值:(打擂台思想)
if(max<a[i]){
max = a[i];
}
二维数组:
int[][] arr = new int[3][5];
int[][] arr = { {1, 2},{3, 4, 5},{5, 6} }
//支持创建列不相等的二维数组
//不是以最长列为基准让每行都等列
arr[i][j] (i 行 j 列)
arr.length: 行数(高度)
arr[i].length: 第 i 行的列数(宽度)
Exception 异常类 //在JDK API 1.6.0中文版中查看常见异常
在毕业之前记住100多个异常
比较字符串大小:s1.compareTo(s2);
//为正数则s1>s2
String.valueOf(num).length();
//返回一个数字有多少位数
双重for循环解决方程组(鸡兔同笼)
解决二维数组输入类型(多个班级学员)
解决双重累加、累乘
for(int aa : 数组名) {
//int aa就是数组的别名
System.out.println(aa);
}
//第四种循环:foreach循环
//变态for循环,只能用来遍历输出
//不能做其他操作
//逆序获取x的各位数
while(x!=0){
i = x%10;//得到x的个位数
x = x / 10;//得到x除了个位数之外的数
}
//判断它是几位数
int count = 0;
while(n != 0)
{
n = n/10;
count++;
}
//生成四位随机数?
int max = 9999;
int min = 1000;
cardNumber = (int)(Math.random()*(max-min)) +min;
//2+22+222+2222..........
巧妙算法:
int a = 2;
int sum = 0;
int num = 0;
for(int i = 1; i <= n; i++)
{
num = num * 10 + a;
sum = sum + num;
}
//1,1,2,3,5,8.......
(也可以用数组做)
用第三变量存中间值:
int a = 1,b = 1,c = 0;
for(int i = 0, i < n; i++)
{
c = a;
a = b;
b = b + c;
}
一个基本数据类型的变量作为参数传递的时候,
在方法里面对形参做修改不会影响实参的
数组做形参,则会改变,涉及到引用地址
int temp = a[0];
a[0] = b[0];
b[0] = temp;
//a, b 作为参数互换两个数组的内容
//对象也是类似数组,引用数据类型
方法重载:
1.方法名相同
2.参数的个数或类型要不同
3.返回类型不理
正确递归:
1.设计正确的递归算法
2.设计一个递归出口
public static int getSum( int n ){
if (n == 0){
return 1;
}
return n + getSum(n - 1);
}
(API 含左不含右)
数组常用方法:
//拷贝数组从a1考到a2
System.arraycopy( a1, 0, a2, 0, 3 );
//二分查找, 必须有序的数据,返回下标
Arrays.binarySearch(a, n);
//快速打印数组内容
System.out.print(Arrays.toString(arr));
//导入数组包
import java.util.Arrays;
//数组排序,默认升序
Arrays.sort(数组名);
//拷贝数组a, 返回4个元素存到b
int[] b = Arrays.copyOf( a, 4 );
//比较两个数组是否相等
Arrays.equals(a, b);
//给d初始化
Arrays.fill( d, 100);
//存大写字母
for( int i = 0, i < 26, i++ ){
str[i] = (char)('A' + i) + "";
}
//输入字符串
String str = s.nextLine();
//全部变成大写字母
toUpperCase()
//获取字符串下标为index的值
str.charAt(index)
//变成字符数组
toCharArray()
//格式化和解析日期的具体类
SimpleDateFormat
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
//Date 类与获取年月的函数
//创建日期对象
Date date = new Date();
//获取年
int year = date.getYear() + 1900;
//获取月
int month = date.getMonth() + 1;
//获取星期,如果没有明确到天,默认返回每月的1号的星期
int day = date.getDay();
java常用算法:
排序都是双重循环
查找都是一重循环
考虑时间复杂度 和 空间复杂度
//顺序查找
int strainghtSearch(int[] num, int n){
for(int i = 0; i < num.length, i++){
if(num[i] == n)
return i;
else
return -1;
}
//折半查找(也叫二分查找,要求集合有序)
//开始的时候min = 0; max = arr.length
while (min <= max) {
int mid = (min + max) / 2;
if (num[mid] == n) {
return mid;
}else if (num[mid] > n) {
max = mid - 1;
}else{
min = mid + 1;
}
}
return -1;
//冒泡排序
for (int i = 1; i < num.length; i++) {//共进行n-1趟
for (int j = 0; j < num.length -i; j++) {
if (num[j] > num[j + 1]) {
int temp = num[j];//比前一个小, 则与之交换
num[j] = num[j + 1];
num[j + 1] = temp;
}
}
}
//直接插入排序
for (int i = 1; i < num.length; i++) {//共进行n-1趟插入
int m = i;
while(m>=1 && num[m] < num[m-1]){//短路表达式
int temp = num[m-1];//比前一个小, 则与之交换
num[m-1] = num[m];
num[m] = temp;
m--;
}
}
面向对象特性:抽象,封装,继承,多态
对象特征:属性(成员变量),行为(方法)
类也是一种数据类型,组合的数据类型
对象是引用数据类型, 数组也是
类是对象的抽象
对象是类的实例化
抽象:
定义类的过程
封装:
1. 将属性和行为封装到一个类,对象
2. 不同的访问权限(public/private)
3. 功能的实现细节要封装
继承:
不劳而获,继承父类(extends)
(父类也叫超类,子类也叫派生类)
1. 直接获得父类已有的东西
2. 改造父类已有的东西
3. 增加自己新的东西
4. java不支持多继承(多个父亲),c++支持
5. java通过接口弥补不能多继承的缺憾
多态:
同一种行为,得到不同的形态
构造方法:
new 对象的时候构造方法执行
系统默认有无参的构造方法
自己定义后默认构造方法不存在了
自己可以重载一个无参构造方法
垃圾对象:
当一个对象失去了所有引用变量引用它的时候(没人在用它了)
对象的比较:
==就是比较两个变量的值是否相等(不包括地址)
equals 是比较两个变量的内容是否相同
obj1 == obj2;//两个地址相等
obj1.equals(obj2) //比较
//java中所有的类都是Object的子类
//Object 类中有equals方法
//重写比较方法
@Override
public boolean equals( Object obj ){
Person p = (Person)obj;
if(this.name.equals(p.name) && this.age == p.age){
return true;
}else{
return false;
}
}
//打印对象
System.out.println(obj.toString());
//重写打印对象方法
@Override
public String toString(){
return "[" + name + " " + age + "]";
}
this 关键字:
代表一个对象 (也代表类)
指当前调用的对象
可以访问本类中的属性和方法
this(); //调用本类的构造方法
this()调用本类构造方法这条语句必须写在构造方法的首行
this()不能调用自己所在的构造方法
this()调用构造方法不能形成闭环
理解main()方法:
public //共有的
static //静态的
void //不需要返回值
String[] //系统传递参数使用的
运行的时候加上系统参数,可以作为args[]打印出来
内存:栈区、堆区、静态区、代码段区
静态变量:
生命周期长,随着类而生
类名可以直接调用
对象共享的变量
用于存对象的值相等的属性
静态方法:
生命周期长,随着类而生
类名可以直接调用
静态方法不可以调用非静态变量(非静态的变量只有在创建对象才会产生,相当于调用了不存在的东西)
也不可以调用非静态方法
用于不访问对象特有值得方法
比如说输出数组,排序数组
总之:
静态有局限性,有共同性
静态方法块:
在类名下面写(类加载就执行,只一次)
父类优先与子类
(但子类的静态代码块优先于父类构造代码块)
主类优先于其它类
构造代码块:
写在类体里面
优先于构造方法
单例模式:
1. (只能产生一个程序窗口的软件)
2. 构造方法私有
3. 定义一个静态的本类对象成员
4. 设计一个公共的静态接口方法
用于返回本类对象
private static Obj obj = null;
public static Obj getObj(){
if(obj == null)
obj = new Obj();
return obj;
}
单例类:
避免创建多个对象
省去了new操作符
类似交易引擎,必须用单例类
单例模式保证不重复命令
不重复交易
对象数组:
和常用的数组差不多
但是要注意对象实例化
(API 含左不含右)
基本数据类型的包装类:
java思想:(一切皆对象)
基本数据类型 包装类
char ---> Character
int ----> Integer
byte -----> Byte
short ------> Short
long -----> Long
float ---> Float
double ----> Double
boolean ---> Boolean
int i = 0;
Integer x = new Integer(i); //老版本装箱过程
int j = x.intValue(); //老版本拆箱过程
//是整形字符串可得整数,若不是整形则报错
int result = Integer.parseInt(“1234”);
//result == 1234
//类似的;Double.parseDouble(str);
(API 含左不含右)
String 类的常见方法:
charAt(index) //返回字符串的index下标的值
toCharArray() //变成字符数组
indexOf("s") //返回str的位置
trim(); //消除字符串两边的空格
str.split("&") //按照一定格式分割字符串
str.replace('a','p') //替换
String.valueOf(x); //将x变成字符串
String a = x + ""; //也可以将x变成字符串
java注释:
文档注释、单行注释、多行注释
继承:(extends关键字)
1. 子类可以直接获得父类已有的东西
2. 子类可以改造或增加父类的方法
3. 子类可以
4. super():父类的构造方法
super:当前类的父类对象(临时对象)
5. 构造方法里面的父类对象只是在创子类的时候暂时存在
6. 私有的成员不能被继承,也不能重写
7. 子类有无参构造方法,父类必须也有
8. super可以访问父类的属性和方法
final 修饰的方法不可重写
final 修饰的类不可继承
9. 向上转型,子类转父类没问题,能运行所有的方法
10. 向下转型,父类转子类,编译的时候要进行强转,运行的时候有时对,有时错
11.如果这个父类引用的是父类实力的话,运行的时候一定出错,无关是否调用的方法是父类和子类中都有的
12.构造方法不能重写,不能继承
修饰符:
protected:不同包非子类不可访问,其他可以
protected: 不能修饰外部类
public:都可用
final 修饰的方法不可重写
final 修饰的类不可继承
多态:(重写、重载、抽象方法、接口实现)
(对象多态性和方法多态性)
方法重载:
1.方法名相同
2.参数的个数或类型要不同
3.必须在同一个类
4.注释:Overload
方法重写:
1.方法名相同
2.参数个数与类型都相同
3.返回值类型子类必须小于父类(类类型才比较)
4.子类的方法权限必须大于或等于父类
5.注释:Override
6.final 修饰的方法不可重写
7.final 修饰的类不可继承
8.构造方法不能重写,不能继承
//重写打印对象方法
@Override
public String toString(){
return "[" + name + " " + age + "]";
}
抽象类:(abstract关键字)
(接口定义一种标准,抽象类定义一种模板)
1.用来作为一个超类继承
2.abstract修饰的类
3.可以包含抽象方法
4.抽象类不具有实例化的能力
5.如果抽象类的子类没有实现父类中的所有抽象方法,那么这个子类依然是一个抽象类
if(animal instanceof Dog){
((Dog)animal).swingTail();
}//判断是否是这个类
(对象 instanceof 类或接口)
void
//从-128---------127 true
Integer i = -129;
Integer j = -129;
System.out.println(i==j);
但是 new出来的==比较都是false
final关键字:
final修饰的类不可继承
final修饰的变量只能赋值一次(只能读)
final修饰的方法不可重写
fun(final int[] arg){
arg[0] = 5;
} //程序没错,args没被赋值
public static final int I = 100;
//全局变量,建议大写
接口:(interface关键字)
(接口定义一种标准,抽象类定义一种模板)
1.接口里面只能包含全局常量和抽象方法
2.里面的变量都默认为全局变量
默认有 public static final 修饰
3.里面的方法都默认为抽象方法
默认有public abstract 修饰
4.接口可以多继承,弥补继承的缺陷
(C++类可多继承,Java不可以)
5.implement 实现
只有调用子类重写父类的方法时,才体现对象多态性
一个接口可以继承多个接口.
interface C extends A, B { }是可以的.
一个类可以实现多个接口:
class D implements A,B,C{ }
但是一个类只能继承一个类,不能继承多个类
class B extends A{ }
在继承类的同时,也可以继承接口:
class E extends D implements A,B,C{ }
类的内部类:
1.可以被任何类修饰符修饰
2.通过外部类点内部类访问
//创建一个内部类对象
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
3.属性有就近原则
4.Outer.this.name //内部类的成员变量
5.不能用super关键字,没用
6.匿名接口实现类(匿名内部类)直接new 对象直接调用,不用事先new对象
方法内部类:(没有什么意义的)
枚举:(用于类似四季,星期几)
enum Color{
yellow,
blue,
gray,
red
}
Color color = Color.red;
Color[] colors = Color.values();
for(Color:value, colors)
{ System.out.print(value);}
java系统常见类:
如果一个类没有构造方法:
1.它里面所有方法都是静态方法
2.如果它里面有静态方法,那么它一定有一个静态的返回此类对象的接口方法runTime()
System 类:
exit(0); //退出系统
System.arraycopy(b,2,a,3,3);//拷贝数组
getProperties() //返回当前系统属性
console(...) //获取当前控制台对象
readPassword(...) //禁止回显,不显示输入的东西
//在cmd里面才能有结果
Console con = System.console();
System.out.println("请输入密码:");
char[] ch = con.readPassword();
String str = new String(ch);
System.out.println(str);
Runtime 类:
(程序运行时)
Math 类:
abs();
cos(); //cos值
cbrt(a);//返回立方根,必须正数,否则返回NaN
round(2.5);//返回最接近的long值,返回3
rint(2.5);//返回最接近的int,返回2
ceil(2.4);//向上取整,返回3
floor(2.4);//向下取整,返回2
Random random = new Random();
//带固定参数的话每次生成的随机数不变
random.nextInt(33)+1;//随机产生1~~33
random.nextDouble();
random.nextFloat();
BigInteger 类:
(大数据操作类)
BigInteger bi1 = new BigInteger("987979879878");
BigInteger bi2 = bil.add(new BigInteger(100000));
String 类:
Date 类:
内存:栈区、堆区、静态区、代码段区
java垃圾回收机制:只负责堆内存,不负责栈区
finalize() //系统自动调用(当对象成为永死状态)
System.gc();//通知系统马上回收垃圾(不通知也会回收)
demo = new Demo();
demo = null;//去活状态
demo = this;//复活(在重写finalize()里面鞋且只有一次复活一次)
传参JVM:右键Run As --->run configuration..
当程序中出现异常,而我们没有处理的时候它交给JVM处理,JVM的处理方式就是结束程序
异常处理机制:
算数异常(ArithmeticException)
数组越界(ArraysIndexOutOfBoundsException)
空指针异常(NullPointException)
输入不匹配(InputMismatchException)
指定的类不存在(ClassNotFoundException)
转换为数字异常(NumberFormatException)
方法的参数错误(IllegalArgumentException)
没有访问权限(IllegalAccessException)
数据类型转换异常(ClassCastException)
文件未找到(FileNotFoundException)
数组存储异常(ArrayStoreException)
方法不存在(NoSuchMethodException)
文件结束异常(EOFEception)
实例化异常(InstantiationException)
内存不足(OutOfMemoryException)
不支持克隆(CloneNotSupportedException)
被中断异常(InterruptedException)
未找到类定义(NoClassDefFoundException)
//循环输入int但出现非int的问题
if(input.hasNextInt()){
x = input.nextInt();
}else{
input.next();
}
或:
try{
x = input.nextInt();
//写可能会出现异常的代码
}catch(Exception e){
input.next();
//写异常处理的代码
}catch(){
//写异常处理的代码
}finally{
//写不管如何一定会输出的代码
//比如数据库连接的close();方法
}
例:
try{
result = i / j;
for(int k = 0; k > 3; k++){
sum = sum1[k] + sum;
}catch(Exception e){
System.out.print("除数为0!");
System.out.print("数组越界");
}//可以两个catch,但是一旦捕获到异常不会继续下面的代码
写多个catch的时候一定要从小到大
try{
if(i < 0 || j < 0) {
//主动抛出异常
throw new ArithemticException();
}else{
result = i * j;
}
}catch(ArithemticException e){
System.out.print("输入的数有负数");
e.printStackTrace();//打印异常的跟踪栈信息
}
自定义异常类:
class MyException extends Exception{
//默认没有构造方法,构造方法不能重写,不能继承
public MyException(String name){
super(name);
}
}
断言语法:
assert boolean 条件
用来调试,现在没什么实用性
注解:(Annotation)
不是简单的对代码的说明
很多框架里面广泛使用
JDK1.5以后引进,与类,接口,枚举一个层次的
功能:
编写文档,(生成doc档)
代码分析,(使用反射)
编译检查,()
系统的三个内定注解:
1.@Override:判断某个方法是否是一个正确的重写的方法,
只能在方法前用(如果不是,则方法报错)
2.@Deprecated:标记某个结构是否是已过时的,
不建议使用,可以使用在类,字段,方法前
3.@SuppressWarnings("all") 压制系统警告的信息(使用需要带参数)
可以使用在类,字段,方法前
系统的四个元注解:(用来定义注解)
1.@Target:定义注解的使用范围
2.@Retention:制定生命周期
3.@Inherited:制定注解是否被继承
4.@Documented:指定注解是否会被生成到doc文档
自定义注解:
@Target({ElementType.FIELD,ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
//变量要记得带括号,参数可以默认值
//自定义类型,接口类型,包装基本数据类型不支持作为参数
//注解类型可以用
public @interface MyAnnotation{
int value() default 3;
int name() default 4;
}
用法:@MyAnnotation(value = 3,name = 5);
//当变量名为value,value可省
JDBC (Java DataBase Connectivity)
java数据库连接,用于执行SQL语句的一组API
数据库有很多种:
Oracle,MySql,SQL Server,DB2,Sybase
1.加载驱动
2.获取数据库的连接对象
3.通过获得数据库连接对象获取一个Statement对象
4.通过Statement对象执行我们想要执行的SQL语句
后知后觉:
1.表设了外键本表可以直接删除
2.被引用表不可删除
3.必须去除引用财会,先删引用它的表
4.可以修改数据,除了外键之外的
5.一般先获取表所有信息存到集合
6.查询、显示可以在集合做
7.数据有更新再访问数据库修改
数据库连接池:
往池子预先初始化几个连接对象,
要用的时候从池子里拿出一个对象来用,
用完归还。
c3p0步骤:
1.导jar包(c3p0-xxx.jar)
2.复制配置文件(c3p0-config.xml)到src下
3.如果直接的用的化就是new一个ComboPooledDataSource
对象然后通过这个DataSource获得Connection 连接对象
4.也可以先封装一个工具类
dbcp步骤:
1.导jar包(commons-dbcp-xx.jar和commons-pool-xx.jar)
2.复制配置文件(xx.properties)到src下
3.如果直接的用的化就是new一个ComboPooledDataSource
对象然后通过这个DataSource获得Connection 连接对象
4.也可以先封装一个工具类
dbutils步骤:
1.导jar包(c3p0-xxx.jar)
2.new QueryRunner(C3PoUtils.getDataSource());
Object类型可以兼容所有类型int double ...
但是Object类型存在类型转换的安全隐患
(万能数据类型)
泛型类的定义:(泛型可以带多个)
class Poit<T,K> {
private T xPos;
private K yPos;
pubic Point(T xPos, K yPos){
this.xPos = xPos;
this.yPos = yPos;
}
public void setxPos(T xPos){
this.xPos = xPos;
}
public T getxPos(){
return this.xPos;
}
}
//实例化
Point<nteger> p = new Point<Integer>(12,23);
泛型类对象之间是不能直接自动转换的
//不同类型不能直接赋值
实例化泛型的类型只能是类类型
类实现泛型接口:
clas IC2<T,K> implements I2<T>{
//如果接口名没有带<T>,系统默认Object
//继承也是同理,系统默认Object
//类可以扩展泛型,但必须带上接口的
//记住:重写参数类型和数量必须一致
}
泛型方法的定义:
//在类里面定义(类不一定为泛型类)
//泛型方法跟泛型类之间不相互影响
public <T> T add(T x, T y){
return x + y;
}
public <T> fun(){
}
publc static <T>
class P<T>{
//T i = 2; 不可
//T[] = new T[5]; 不可
//初始化方法
public void set(T a, T[] b){
i = a;
T[] = b;
}
}
new 泛型数组的时候不要用<>
MyGener<Integer>[] mgs = new MyGener[5];
mgs[0] = new MyGenr<Integer>();
泛型类充当泛型的实例化类(嵌套)
Test<Info<String,Integer>> t = new Test<Info<String,Integer>>();
Info<String,Integer> info = new Info<String,Integer>();
info.setValue("hehe");
info.setV(34);
t.setValue(info);
通配符,能读不能写
受限泛型:
设置上限:
class MyGener<T extends Number>{
}
public static void show(Test<? super Number>test)
设置下限:(只能在声明对象的时候用)
数据结构:
线性:
顺序表:
栈:先进后出
队列:先进先出
链式存储:
单链表,多链表
class Node{
int iData; //数据域
Node pNext; //指针域
}
main(){
Node node123pHead = new Node();
node1.pNext = node2;
node2.pNext = node3;
pHead = node1;
}
非线性:
树
图
集合:
list.size() //元素个数,不是集合大小
remove(index) //删除,通过下标或者通过元素
输出集合:
1.直接用System.out.println(list);
2.通过for循环 或者 for_each循环
3.通过迭代器遍历
Iterator<Integer> it = list.iterator
while(it.hasNext()){
}
elementt() //获取但不移除列表的头元素
peek() //获取但不移除列表的头元素
poll() //获取并移除第一个元素
romove()//默认移除第一个元素
peekLast()
pop() //出栈 获取并移除第一个元素
push() //入栈
offer() //往后添加
getFirst() //
getLast()
clone()
list:
ArrayList和LinkList
有序插入
treeSet:(sortedSet的唯一实现类)
会自动排序,也无插入顺序
set:
无插入顺序,取决于哈希地址
且内容不重复,且去重
如果需要判断对象是否相等,需要
重写equals()方法和hashCode()方法
public boolean equals(Obj o){
Person p = (Person)obj;
if(){ return ture}
else(){ return false}
}
public int hashCode(){
return name.hashCode() + age;
}
可自动生成重写的方法
如果重写了compareTo()方法,可以不用重写
hashCode(),equals()方法也可以实现去重
JVM:
JAVA 反射机制:
1.获取反射入口,也就是获取Person类的Class实例
ClassLoader loader = ClassLoader.getSystemClassLoader();
//第一种方法加载类实例
Class c = loader.loadClass("com.itjob.Person");
//第二种方法加载类实例
Class.forName("com.itjob.Person");
//第三种方法加载类实例
Person p = new Person();
Class c = p.getClass();
//第三种方法加载类实(比较有效,不用知道包名)
Class c = Person.class;
2.通过相应的反射API完成相应的反射操作
//实际中一般不用这种
Person p = (Person)c.newInstance();
getConstructor();//获取指定的构造方法
getConstructors();//获取到所有的构造方法
getMethod();
getMethods();
Class c = Person.class;
Class cs = c.getSuperclass();
Class[] inters = c.getInterfaces();
Constructor[] cons = c.getDeclaredConstrutors();
Constructor con = c.getDeclaredConstrutor(String.class,int.class)
Person p = (Person)con.newInstance();
Class[] types = m.getParameterTypes();
getXXX():获取当前类和父类继承下来的XXX结构,不包含非public
getDeclaredXXX():包含非public
Method m = c.getDeclaredMethod("fun");
m.invoke(p); //通过反射调用
m.setAccessible(true);
sql语句拼接变量存在危险:
aaa' or '1'='1
//配置文件
src ---> new ----> file
file name : db.properties
driverclassname = com.mysql.jdbc.Driver
url = jdbc:mysql:///student?useUnicode=true&characterEncoding=utf-8
usernme=root
password=123456
static{
1.通过ResourceBundle类来加载资源源文件中的配置数据
ResourceBundle bundle = ResourceBundle.getBundle("db");
driverClassName = bundle.getString(driverClassName);
...
2.通过Properties类来加载资源源文件中的配置数据
Properties p = new Properties();
InputStream inStream = JDBCUtil.class.getClassLoader().getSystemResourceAsStream("db.properties");
p.load(inStream);
driverClassName = p.getProperty("driverClassName");
}
线程、进程:
进程:程序一次动态执行的过程
线程:进程已线程为单位,为了数据共享
n(至少一个)个线程组成一个进程
进程中必须有主线程
轮换快,与同时进行一样
实现多线程的两种方式:
1.通过Tread类实现
自定义一个类继承Tread类
重写run()方法,也就是线程方法
我们需要这个线程做的事都应该放到此方法中来自做
在需要创建一个线程的地方new一个自定义线程对象,
//运行时不能调用run(),否则没差别
2.通过Runnable接口实现
自定义一个类实现Runnable接口
重新run()方法,一样的
运行时:
MyThread1 mtr1 = new MyThread1();
new Thread(mtr1).start();
只有在run()方法里面跑的才是子线程
wait(); //等待
notify(); //通知
多线程解决阻塞
IO 流:
字节流、字符流、管道流
字节流:InputStream OuputStream
FileInputStream FileOuputStream
字符流:
File f1 = new File ("C;\\aaa\\1.txt");
得到类型对象
f1.createNewFile();
创建对象
绝对路径:
从系统的根目录出发的路径
相对路径:
不是从系统根目录出发的路径
字符流---->字符流的转换:
InputStreamReader
OutputStreamWriter
字符编码:
ASCII
GBK, GB2312
BIG5:繁体中文
unicode
utf-8
ISO-8859-1:单字节
支持中文的字符集:GBK, GB2312, utf-8
乱码原因:
两端使用的字符编码不一致
编码:字符--->byte[] String.getByte()--->byte[]
解码:byte[]---->字符 new String(byte[], charset)
对象序列化:(串行化)
将对象转换为二进制流
java网络编程:
TCP:
1.三次握手
2.面向连接
3.安全可靠
4.传输速度慢
UDP:
InetAddress 类的使用:
ServerSocket 类的使用:
服务器:
创建服务器套接字
绑定IP和端口
等待客户端的连接请求(如果有客户端连接上来就会产生一个与客户端的连接套接字)
收发数据
关闭与客户端的连接套接字
关闭服务器
客户端:
创建一个客户端的套接字
发送一个请求(如果服务开启则)
基于这个连接进行收发数据
关闭这个连接
按位取反:
快捷算法:相反数-1
~4567 = -4567 - 1 = -4568
~(-2345)= 2345 - 1 = 2344
// Springframework的jar包
https://repo.spring.io/release/org/springframework/spring/