java SE 乱记（一）

正数：
源码：即对应的二进制
源码，反码，补码一样
负数：
反码 = 最高位之后全取反，最高位不变
补码 = 反码 + 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/

感谢您的阅读，欢迎参观我的个人网站：知行乐集【www.zhixinglj.cn】