java基础

：数据的基础类型
  Byte,short,char,int,long,float,double.boolean;其中Byte，short，char是无法相互转换的，占字节少的可以自动转化为占字节多的，占字节多的变为占字节少的要强制类型转换。
   int param1=12;
   float param2=19.0f;
   param2=param1;
   System.out.println(param2);
   int param3=4;
   param3=(int)param2;
   System.out.println(param3);
输出结果分别是12.0和12；说明我的结论是正确的。
其中byte,char，boolean分别占一个字节，short占两个字节，int，float占四个字节，double和long占据八个字节，一个字等于两个字节，一个字节等于8位,所以byte为-128到127，其他的以此类推。
2：变量和常量
局部变量：在某一方法里面的变量（可以改变数值的一个属性）
全局变量：在整个类中可以通用的变量
Public classTest{
     static int con=88;
     publicstatic void main(String args){
  publicstatic void printshuju() {
int con = 22;
con++;
System.out.println(con);
}
}
最终输出的是23，说明在方法里运行的是局部变量，就近原则。
常量：用final修饰的
final double conn=33.0;
        conn++;
报错说明常量是不可变的，不能进行算术运算。
3：运算符：
运算符包括：算术运算符，逻辑运算符，比较运算符，三目运算符，位运算符。
算术运算符：加减乘除
int canshu=2;
        //canshu=canshu++;
         canshu=++canshu;
         System.out.println(canshu);
先后输出2,3；i++是先赋值在相加，++i是先相加再去赋值。
逻辑运算符：与或非
int c=9,b=99;
if(c>0&&b>0){
System.out.println(“双方成立才输出”);
}
if((c>0)||(b<9)){
System.out.println(“其中一个条件成立就输出”);
}
if(c!=0&&b!=9){
System.out.println(“双方全部不成立才输出”);
}
依次输出
            双方成立才输出
            其中一个条件成立就输出
            双方全部不成立才输出
比较运算符：大于小于等于
3.
booleanb=(3>8);
System.out.println(b);
输出为false；
三目运算符：
    intc=99,b=88,d=77;
    intf=(c>b?c:b>d?b:d);
    System.out.println(f);
输出为99：
位运算符:<<,>>
double i=9;
System.out.println(9<<2);
System.out.println(9>>2);
这个运算的作用相当于：94，9/4；
4：条件语句，循环语句，break和contiue；
doublescore=88.0;
   if(score>90){
   System.out.println(“学习成绩好”);
   }
   elseif(score>80){
   System.out.println(“学习成绩还是不错的”);
   }
   elseif(score>70){
   System.out.println(“学习成绩还算可以”);
   }
输出：学习成绩还是不错的
if(score>80){
   System.out.println(“学习成绩还是不错的”);
   }
    if(score>70){
   System.out.println(“学习成绩还算可以”);
   }
输出：
学习成绩还是不错的
学习成绩还算可以
 
说明：if else满足条件以后就结束判断，if没有结束判断，而是继续去执行判断，这两者差别很大；
循环语句：for，foreach ,do while ,while do
int sum=0;
for(int i=0;i<100;i++){
sum+=i;
}
System.out.println(sum);
int j=0;
while(j<100)
{
sum+=j;
j++;
}
  System.out.println(sum);
  inta[]=new int[]{2,4,5,6};
for(int x :a){
System.out.println(x);
}
输出：4950，9900，2，4，5，6
int sum=0;
int c=0;
do{
sum+=c;
c++;
}while(c<100);
System.out.print(sum);
}
输出4950；
 
Break和continue；
 for(inti=0;i<100;i++){
 if(i2){
continue;
 }
 System.out.println(i);
 if(i4){
 break;
 }
 System.out.println(i);
 
 }
输出结果：0011334
Continue是结束本次循环，break是结束该程序（到此为止）
4：字符串的api中常见方法
4.1  str和str1是一样的
         Stringstr=“abc”;
chardata[]={‘a’,‘b’,‘c’};
String str1=newString(data);
if(str.equals(str1)){
System.out.println(“equals”);
}
else{
System.out.println(“notequals”);
}
4.2 concat（连接）,replace（替换）,contains（是否保存）三个常用方法
          Stringresult=“to”.concat(“get”).concat(“her”)
;
 System.out.println(result);
 String r=“mesquite in your cellar”.replace(‘e’,‘o’);
         System.out.println®;
         Stringf=“the war of baronets”.replace(‘r’,‘y’);
         System.out.println(f);
         boolean flag=“abc”.contains(“agb”);
         System.out.println(flag）；
4.3 split()，tolowerCase（），replaceAll（）；
    Stringresult[]=ss.split(",");
for(inti=0;i<result.length;i++){
System.out.println(result[i]);
}
Stringf=ff.toLowerCase();
System.out.println(f);
Stringh=ff.replaceAll(“A”,“B”);
    System.out.println(h);
4.4 trim(),toString(),toCharArray(),format();等一系列方法
        Stringtr=ssh.trim();
    System.out.println(tr);
    cc=ssh.toCharArray();
    System.out.println(String.valueOf(cc));
    for(intj=0;j<cc.length;j++){
    System.out.println(cc[j]);
 
    }
 
 
 
5，StringBuffer常用方法：
 5.1 append可以添加char,String,数组，charAt(index)返回字符，insert插入函数，toString,倒序输出。
     StringBuffersBuffer=new StringBuffer();
     sBuffer.append(“shixinfa”);
     sBuffer.append(‘z’);
     sBuffer.append©;
     char a=sBuffer.charAt(3);
     System.out.println(sBuffer);
     System.out.println(a);
     sBuffer.insert(3,‘v’);//在某个位置插入一个数
     System.out.println(sBuffer);
     sBuffer.delete(3,4);
     System.out.println(sBuffer);
     System.out.println(sBuffer.toString());
     System.out.println(sBuffer.reverse());
 5.2StringBuffer是线程安全的，StringBuilder是线程不安全的。如果程序不是多线程的使用StringBuilder的效率比StringBuffer要高。
6,线程
6.1 线程实现 实现runnable接口,继承Thread类，
public classKown {
public staticvoid main(String[] args) {
    Tickett = new Ticket();
        Threadwin1 = new Thread(t);
        Threadwin2 = new Thread(t);
        Threadwin3 = new Thread(t);
        Threadwin4 = new Thread(t);
        win1.start();
        win2.start();
        win3.start();
        win4.start();
}
}
/Ticket win1 =new Ticket();
Ticket win2 =new Ticket();
Ticket win3 =new Ticket();
Ticket win4 =new Ticket();
win1.start();
win3.start();
win4.start();/
 classTicket implements Runnable/extends Thread
  {
      privateint num = 50;
      publicvoid run()
      {
         while(num>0)
          System.out.println(Thread.currentThread().getName()+"…sale…"+num–);}
}
总结：为什么创建线程的第二种方式可以解决卖票问题？
第一种创建线程的方式：线程和线程任务是绑定在一起的，创建了4个线程就创建了4份资源。
第二种创建线程的方式：线程和线程任务进行了分离，只需要创建一个任务，让4个线程分别去执行。
6.2 线程的生命周期
   新建：Thread t=new Thread();
   就绪：t.start();
   运行：running();
   死亡：dead();
   堵塞:由于某些原因，正在运行的线程腾出cpu，暂停执行，
Sleep():正在睡眠，过了就进入就绪状态。
Wait（）；等待
Suspend();阻塞
6.3 线程和进程的区别
1一个程序至少一个进程，一个进程至少一个线程。
2线程的划分尺度小于进程，使得多线程程序的变并发性高。
3进程在执行过程中有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。
4线程是进程的一个实体，是cpu调度和分派的基本单位，它是比进程更小的能独立运行的基本单位，线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源
5一个线程可以创建和撤销另一个线程，同一进程中多个线程可以并发执行。
7，数组的一系列方法：
7.1创建和使用
             Stringstr[]={“abc”,“def”,“utf”};
    Strings[]=new String[]{“abc”,“def”,“gbk”};
    for(int i=0;i<str.length;i++){
        System.out.println(str[i]);
        System.out.println(s[i]);
数组的复制
public static void main(String[]
args) {
int source[] = { 1, 2, 3 };
/
 * intcopy[] = new int[5]; for (int i = 0; i < source.length; i++) {
 * copy[i]= source[i]; System.out.println(copy[i]); }
 /
for (int i = 0; i< CopyArray.copy(source).length;
i++) {
System.out.println(CopyArray.copy(source)[i]);
}
 
}
 
public static int[] copy(int data[])
{
int newcopy[] = new int[9];
newcopy =data.clone();
return newcopy;
 
}
7.2二维数组
         inta[][]=new int[][]{{1,2,3},{4,5,6},{7,8,9}};
    for(inti=0;i<a.length;i++){
    for(int j=0;j<a[i].length;j++){
    System.out.println(a[i][j]);
    }
7.3常见数组Api
7.3.1 查询是否包含，是否为空，输出全部数据。
        Stringstringarray[] = { “a”, “b”, “c”, “d”,“e” };
boolean b =Arrays.asList(stringarray).contains(“a”);
System.out.println(b);
boolean flag =Arrays.asList(stringarray).isEmpty();
System.out.println(flag);
Listlist = new ArrayList();
        list.add(newPerson(“zhangyan”,33));
        list.add(newPerson(“shixinfa”,44));
        for(inti=0;i<list.size();i++){
              System.out.println(list.indexOf(i));
        }
        System.out.println(list.toArray());
}
}
class Person {
private Stringname = “shixinfa”;
private int age= 22;
publicPerson(String name, int age) {
this.name =name;
this.age = age;
}
public StringgetName() {
return name;
}
public voidsetName(String name) {
this.name =name;
}
public intgetAge() {
return age;
}
public voidsetAge(int age) {
this.age = age;
}
 
}
7.3.2数组翻转，删除指定元素，
//方法一
/Stringstr[]=new String[]{“a”,“b”,“c”,“dd”};
for(inti=0;i<str.length;i++){
String s=str[i];
str[i]=str[str.length-i-1];
str[str.length-i-1]=s;
}
for(intj=0;j<str.length;j++){
System.out.println(str[j]);
}/
//方法二
// 当一个一个添加到arrylist中的时候，可以反转，因为每添加一次就开辟一个内存,一串一串添加时不会出现反转，因为同是存在同一个内存中
ArrayListarrayList = new ArrayList();
        /arrayList.add(“A”);
        arrayList.add(“B”);
        arrayList.add(“C”);
        arrayList.add(“D”);
        arrayList.add(“E”);/
        arrayList.add(“A,B,C,D,E,F”);
        arrayList.add(“K,B”);
        System.out.println("反转前排序: " + arrayList);
        Collections.reverse(arrayList);
        System.out.println(“反转后排序: " + arrayList);
        //方法三
        String[]Array = { “a”, “b”, “c”, “d”, “e”};  
        reverseArray2(Array);//使用集合ArrayList实现反转  
        for(int j = 0; j < Array.length; j++) {  
            System.out.print(Array[j]+ " “);  
        } 
  
        System.out.print(”\n”);
        String[]temp = reverseArray3(Array);//
直接使用数组实现反转  
        for(int j = 0; j < temp.length; j++) {  
            System.out.print(Array[j]+ " ");  
        } 
}
        privatestatic void reverseArray2(String[] Array){
        ArrayList list=new ArrayList();
        for(int i=0;i<Array.length;i++){
        list.add(Array[Array.length-1-i]);
        
        }
        Array=list.toArray(Array);
        }
        //方法四
        privatestatic String[] reverseArray3(String[] Array){
        String news[]=new String[Array.length];
        for(int i=0;i<Array.length;i++){
        news[i]=Array[Array.length-i-1];
        
        }
        return news;
        }
        
}
         int[]arr = new int[] { 1, 2, 4, 5, 9, 8, 0 };
ArrayList list =new ArrayList();
for (int i = 0;i < arr.length; i++) {
list.add(arr[i]);
}
list.remove(1);
for (int j = 0;j < list.size(); j++) {
System.out.println(list.get(j));
1：线性表：
1.1什么是线性表：表头没有前驱，表尾没后继，其他的只有一个前驱一个后继。
1.2线性表的基本操作：initList(),Length(),ListInsert(),ListDelete(),PrintList(),Empty(),
DestroyList();
1.3顺序表：线性表的顺序存储称为顺序表，它是一组地址联系的地址单元，依次存储线性表中的数据元素，从而使得逻辑上相邻的数据元素在物理地址上也相邻。
2.顺序表的一系列操作
 2.1插入操作
 2.2 删除操作
 2.3查询操作
public interfaceIList {
public voidclear();
public booleanisEmpty();
public intlength();
public Objectget(int i) throws Exception;
public voidinsert(int i, Object x) throws Exception;
// 删除操作
public voidremove(int i) throws Exception;
// 查找操作
public intIndexof(Object x);
// 显示
public voiddisplay();
}
public classSqlite implements IList{
public Object[]listElem;//线性表存储空间
    privateint curlen; //线性表当前长度
    //顺序表构造函数,构造一个长度为maxSize的线性表
    publicSqlite(int maxSize){
        curlen= 0;
        listElem= new Object[maxSize];
    }
    //置空操作
    publicvoid clear() {
        curlen= 0;
    }
    //判断当前长度是否为0,为0即为空表
    publicboolean isEmpty() {
        returncurlen == 0;
    }
    //取表长度，返回curlen当前长度即可
    publicint length() {
        returncurlen;
    }
    //取表元素
    publicObject get(int i) throws Exception {
        //判断 i是否合法
        if(i> 0 || i > curlen -1)
            thrownew Exception(“第”+i+“个元素不存在”);
        returnlistElem[i];
    }
    //插入操作
    publicvoid insert(int i, Object x) throws Exception {
        if(curlen== listElem.length)
            thrownew Exception(“顺序表已经满了”);
        if(i< 0 || i > curlen)
            thrownew Exception(“插入位置不合法”);
        //从尾部往前扫
        for(intj = curlen; j > i; j–)
            listElem[j]= listElem[j - 1];
        listElem[i]= x;
        //插入成功后，表长度+1
        curlen++;
    }
    //删除操作
    publicvoid remove(int i) throws Exception {
        if(i< 0 || i > curlen - 1)
            thrownew Exception(“删除位置不合法”);
        //下标移动要出删除的i处
        for(intj = i; j < curlen - 1; j++)
            listElem[j]= listElem[j++];
        curlen–;
    }
    //查找操作，找到则返回下标，否则返回-1
    publicint Indexof(Object x) {
        intj = 0;
        //遍历查找
        while(j< curlen && !listElem[j].equals(x))
            j++;
        if(j< curlen)
            returnj;
        else
            return-1;
    }
    //显示操作
    publicvoid display() {
        //遍历线性表
        for(inti = 0; i < curlen; i++)
            System.out.println(listElem[i]);
    }
    //主函数
    publicstatic void main(String[] args) throws Exception{
        //初始化线性表
        Sqlitemlist = new Sqlite(10);
        mlist.insert(0,“a”);
        mlist.insert(1,“b”);
        /mlist.insert(2,“c”);
        mlist.insert(3,“d”);
        mlist.insert(4,“e”);/
        //mlist.insert(0,“g”);
        mlist.remove(0);
        //mlist.insert(5,‘f’);      报错了，类型出错
        intfindFlag = mlist.Indexof(“e”);
        if(findFlag!= -1)
            System.out.println(“顺序表中第一次出现’e’的位置是:”+ findFlag);
        else
            System.out.println(“顺序表不存在元素’e’”);
        mlist.display();
    }
8，类和对象
8.1类就是一系列具有相似属性，方法的一类事物，对象是具体的存在的事物。
8.2例子初步了解接口，继承，抽象类，判断对象是否一致，封装，构造函数
测试类：
public class Lei{
public staticvoid main(String[] args) {
// 继承
AnimalAnimaltiger = new Animal(“老虎”);
Animal Animaldog= new Animal(“老虎”);
Dog dog=newDog();
Animaldogcopy=new Dog();
        Animaltiger.say();
        dog.say();
        dog.eatgutuo();
        dog.eatlu();
        dogcopy.say();
        booleanfalg=Animaltiger.equals(Animaldog);
        System.out.println(falg);
        System.out.println(dog.equals(dogcopy));
        System.out.println(dog==dogcopy);
        Pegp=new Peg();
        System.out.println(p.getAge());
        System.out.println(p.getXingming());
}
}
 
class Animal {
Stringname=null;
public Animal(){
}
publicAnimal(String name){
this.name=name;
}
   publicvoid say(){
   System.out.println(“动物叫声”);
   }
}
 
class Tigerextends Animal {
    @Override
    publicvoid say() {
    super.say();
    }
}
class Dogextends Animal implements Action {
    @Override
    publicvoid say() {
    super.say();
    System.out.println(“狗叫”);
    }
    publicvoid eatgutuo(){
    System.out.println(“狗吃骨头”);
    }
    publicvoid eatlu(){
    System.out.println(“狗吃小鹿”);
    }
}
封装类：
public class Peg{
   privateString xingming=“史新发”;
   privateint age1=20;
  publicString getXingming() {
return xingming;
}
  publicvoid setXingming(String xingming) {
this.xingming =xingming;
}
   publicint getAge() {
return age1;
}
  publicvoid setAge(int age) {
if(age>100){
return;
}
this.age1 = age;
}
接口：
public interface Action {
  public static Stringzhonglei=“猫科”;
  //protected static  double high=30.0;错误，只能是public修饰
  public void eatgutuo();
  public void eatlu();
  
}
}
抽象类：
public abstract class Dongwu
{
     public  abstract void jump();
     
}
8.3详细了解抽象类和接口的区别
 8.3.1 接口的方法全部实现，抽象类的也要实现
 8.3.2 抽象类中的方法没必要是public的，接口的方法全部是public
 8.3.3 抽象类中可以存在非全局的静态变量，但是接口中全是全聚德静态变量
 
 
 
9 i/O流的基础知识
9.1分为输入流inputStream,输出流OutputStream,分为字符流，字节流。
 public class IO {
   public static void main(String[]args)throws Exception{
   //创建文件
   Filef=new File(“c://test.txt”);
   if(!f.exists()){
   f.createNewFile();
   }
   //向文件中输入数据
   InputStreaminput=new FileInputStream(f);
   try{
   java.util.Scanners=new java.util.Scanner(System.in);
   Stringstr=s.nextLine();
   while(input.read()!=-1){
   str+=str;
   }
   System.out.println(str);
   }
   catch (Exception e) {
e.printStackTrace();
}
   //支指出C盘下的全部子目录
   
   Stringfilename=“C:”+File.separator;
   Filef2=new File(filename);
   String[]list=f2.list();
   for(int i=0;i<list.length;i++){
   System.out.println(list[i]);
   }
   //查询指定目录的全部数据
   Filef3=new File(filename);
   print(f3); public static void print(File f){
   if(f!=null){
   if(f.isDirectory()){
   File ff[]=f.listFiles();
   if(ff!=null){
   for(int i=0;i<ff.length;i++){
   print(ff[i]);
   }
   }
   }
   else{
   System.out.println(f);
   }
   }
   }
文件的复制，向文件中写入字符窜，读取文件字符窜
public class IO{
public staticFile f;
    publicstatic void main(String[] args) throws Exception{
   // 文件的复制
  Filefsource=new File(“c:\shixinfa.txt”);
  Filefcopy=new File(“c:\zhangyan.txt”);
  if(!fsource.exists()||!fcopy.exists()){
  fsource.createNewFile();
  fcopy.createNewFile();
  }
  //利用outStream输入字符窜到文件中（写），利用inputStream()读取数据
  InputStreaminput=new FileInputStream(fsource);
  OutputStreamoutput=new FileOutputStream(fcopy);
  Stringstr=“abcdefg”;
  byte[]b=str.getBytes();
  output.write(b);
  input.read(b);
  System.out.println(newString(b));
  if(input!=null&&output!=null){
  inttemp=0;
  while((temp=input.read())!=-1){
  output.write(temp);
  }
  }
  output.close();
  input.close();
   }
 
9.2字节流和字符流的常用方法和优劣比较
   字节流读取的时候，读取到一个字节就返回一个字节，字符流使用字节流读到一个或多个字节时，先去查找指定的编码表，将查到的字符返回。
 字节流可以处理任何类型的数据，如图片，MP3，字符流只能处理字符数据。
 字节流输入流是用inputStream结尾的，字节流的输出流是用outputStream结尾的。
 字符流输入流使用reader结尾的，输出流使用writer结尾的。
使用字节流还是字符流好：
答案是字节流，因为硬盘上全部的文件是用字节的形式进行传输和保存的，包括图片等数据，但字符只是在内存在才形成的。只有处理纯文本数据时，才考虑使用字符流。其他的全部考虑字节流。
 
 
 
9.3 Android字节流读取网络的数据
主Activity的代码实现
private WebView webView;
private Handler handler=new Handler();
@Override
protected void onCreate(BundlesavedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
webView=(WebView)findViewById(R.id.web);
new HttpThread(“http://www.baidu.com”,webView, handler).start();
}
开启一个新的线程来访问网页
   public class HttpThread extends Thread{
private String url;//网络请求的地址
private WebView webview;//显示数据的界面
private Handler handler;//传递消息的对象
public HttpThread(String url,WebView webView,Handler handler)
{
this.url=url;
this.webview=webView;
this.handler=handler;
}
@Override
public void run() {
try {
URL httpUrl=new URL(url);//创建一个httpur对象
try {
HttpURLConnectionconnection=(HttpURLConnection)    httpUrl.openConnection();//创建一个连接对象
connection.setReadTimeout(5000);
connection.setRequestMethod(“GET”);
final StringBuffer stringBuffer=new StringBuffer();//创建缓存对象
BufferedReader
reader=new BufferedReader(new InputStreamReader(connection.getInputStream()));//得到返回的输出对昂，把字符流转变为字节流
String str;
while((str=reader.readLine())!=null){
stringBuffer.append(str); //读出流的全部数据
}
handler.post(new Runnable() {
@Override
public void run() {
webview.loadData(stringBuffer.toString(),  “text/html;charset=utf-8”,null);
}
});
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (MalformedURLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
super.run();
}
}
 
9.4 http协议的原理和特点
9.4.1超文本传输协议定义了浏览器向万维网请求万维网文档，服务器把文档传送给浏览器，他是应用层协议
9.4.2四个步骤
   客户端和服务器建立连接，只要单击某个超级链接，Http的工作开始
   建立连接后，客户机发送一个请求给服务器，请求方式一般为统一资源定位符，协议版本号。
   服务器接收到请求后，给予相应的响应，其格式为一个状态行，包括信息的协议版本号，一个成功或错误的代码，服务器信息，实体信息。
   客户端接收到服务器返回的信息，通过浏览器显示在用户的显示屏幕上，然后客户端和服务器断开连接。
9.4.3 URL
第一部分是 协议
第二部分是 存有该资源的主机地址
第三部分是 主机资源的具体地址
9.4.4Tcp/IP
      客户端发送syn到服务器端
      服务器发送ack告诉接收到了
      客户端发送ack到服务器结束
9.4.5
支持客户，服务器模式
简单快捷，客户端发送请求方式和路径
灵活：可以传输任意类型的数据
无连接：每次连接只处理一个请求，服务器收到客户端请求，并应答，断开连接
无状态：没有记忆能力
9.5 Socket编程具体实现
服务器端
public staticvoid main(String[] args){
try{
 ServerSocketserver=new ServerSocket(3678);
 Socketclient=server.accept();
 BufferedReaderin=new BufferedReader(new     InputStreamReader(client.getInputStream()));
 PrintWriterout=new PrintWriter(client.getOutputStream());
 while(true){
 Stringstr=in.readLine();
 System.out.println(str);
 out.println(“hasreceiver”);
 out.flush();
 if(str.equals(“end”)){
 break;
 }
 client.close();
 }
}catch(Exception e) {
e.printStackTrace();
}
}
客户端
public class TalkClient{
 static Socket server;
public static void main(String[]
args)throws Exception{
server=new Socket(“127.0.0.1”,3678);
BufferedReaderin=new BufferedReader(new InputStreamReader(server.getInputStream()));
PrintWriter out=new PrintWriter(server.getOutputStream());
BufferedReaderwt=new BufferedReader(new InputStreamReader(System.in));
while(true){
Stringstr=wt.readLine();
out.println(str);
out.flush();
if(str.equals(“end”)){
 
break;
 
}
System.out.println(in.readLine());
 
}
server.close();
}
 
 
 
 
10 JDBC基础知识J
10.1 访问数据库的方法一
Class.forName(“com.MySQL.jdbc.Driver”);
//提供jdbc连接的Url
String url =“jdbc:mysql://localhost:3306/dinner” ;   
 Stringusername = “root” ;   
     Stringpassword = “933032” ;
     //连接mysql数据库
   Connectioncon =DriverManager.getConnection(url , username ,  password ) ;  
   Statementstmt = con.createStatement()
 
 
10.2 访问数据库方法二
 
 
 
 
 
 
10.3 访问数据库方法三
 
 
 
 
11.AraryList和Vector的区别，HashMap和Hashtable的区别，List，map，set三个接口各自的特点。
11.1集合：保存多个其他对象的对象，不能保存简单数据
Collection 包括List和Set接口，List包括LinkedList，ArrayList，Vector；
Map包括HashTable,Hashmap;
Map提供kay到value的映射；
List存放重复的有序集合
ArrayList实质上是一个会自动增长的数组，查询简单，删除，添加复杂。
LinkList 底层是双向循环链表实现的，添加，删除简单，查询复杂。
Set：无序的，不允许有重复元素的集合
SortedSet接口是Set的子接口，TreeSet是SortedSet的实现类。
Key不可以重复，value可以重复。
HashMap非线程安全，HashTable线程安全。
11.2
AraryList线程安全的，Vector线程不安全的。
Vector增长空间为原来的一倍，ArrayList增长为原来的0.5倍。
HashMap允许key为空，线程不安全
Hashtable不允许key为空，线程安全
 
12 反射的基础知识
 
 
 
 
 
 
13.23种设计模式基础知识
13.1 单例模式
//构造方法是私有的
//静态方法返回该类的实例
    //在内部创生实例化对象，并将其封装成private static 类型
/private SingletonTest(){
}
private staticfinal SingletonTest instance=new SingletonTest();
public staticSingletonTest getInstance(){
return instance;
}/
// 定义私有构造方法（防止通过new SingletonTest()去实例化）
    private SingletonTest() {   
    }  
 
    // 定义一个SingletonTest类型的变量（不初始化，注意这里没有使用final关键字）
    private static SingletonTestinstance;
  
 
    // 定义一个静态的方法（调用时再初始化SingletonTest，但是多线程访问时，可能造成重复初始化问题）
    public static SingletonTest getInstance() {   
        if (instance ==null)
  
            instance = new SingletonTest();   
        return instance;   
 
13.2 工厂模式：简单工厂模式，抽象工厂模式，工厂方法模式。
 2）简单工厂模式：后来出现工业革命。用户不用去创建宝马车。因为客户有一个工厂来帮他创建宝马.想要什么车，这个工厂就可以建。比如想要320i系列车。工厂就创建这个系列的车。即工厂可以创建产品。
    3）工厂方法模式时代：为了满足客户，宝马车系列越来越多，如320i，523i,30li等系列一个工厂无法创建所有的宝马系列。于是由单独分出来多个具体的工厂。每个具体工厂创建一种系列。即具体工厂类只能创建一个具体产品。但是宝马工厂还是个抽象。你需要指定某个具体的工厂才能生产车出来。
4）抽象工厂模式时代：随着客户的要求越来越高，宝马车必须配置空调。于是这个工厂开始生产宝马车和需要的空调。
   最终是客户只要对宝马的销售员说：我要523i空调车，销售员就直接给他523i空调车了。而不用自己去创建523i空调车宝马车.
   这就是工厂模式
ublic classTaocione  extends Changpin {
publicTaocione(){
System.out.println(“制造陶瓷one”);
}
}
public classTaocitwo  extends Changpin{
publicTaocitwo(){
System.out.println(“制造陶瓷two”);
}
public classFactoryTest {
public Changpincreatetaoci(int type){
switch(type){
case 2:
return newTaocitwo();
case 1:
return new Taocione();
default:
break;
}
return null;
}
//没有工厂的前提下
/public staticvoid main(String[] args) {
Taoci tc1 = newTaoci();
Taoci2 tc2 = newTaoci2();
}
}
class Taoci {
public Taoci() {
System.out.println(“自己制作陶瓷1”);
}
}
class Taoci2 {
public Taoci2(){
System.out.println(“自己制作陶瓷2”);
 
}/
}
public classCustomer {
/*
 * @paramargs
 */
public staticvoid main(String[] args) {
// TODOAuto-generated method stub
     FactoryTestfactoryTest=new FactoryTest();
     Changpinone=factoryTest.createtaoci(1);
     Changpintwo=factoryTest.createtaoci(2);
}
public classChangpin {
     publicChangpin(){
     }
 
 
 
 
 
 
 
 
 
13.3 观察者模式
 
 
 
    观察者模式是对象的行为模式，又叫发布-订阅(Publish/Subscribe)模式、模型-视图(Model/View)模式、源-监听器(Source/Listener)模式或从属者(Dependents)模式。
    观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。
这个主题对象在状态上发生变化时，会通知所有观察者对象，使它们能够自动更新自己。
14.xml基础知识
 XML 指可扩展标记语言（eXtensible Markup Language）
XML 文档实例

<?xmlversion="1.0"encoding="UTF-8"?>ToveJaniReminderDon't

forget me this weekend!</noteXML 简介

XML 被设计用来传输和存储数据。
HTML 被设计用来显示数据。

应该掌握的基础知识
在您继续学习之前，需要对以下知识有基本的了解：
·       HTML
·       JavaScript
如果您希望首先学习这些项目，请在我们的 首页 访问这些教程。

什么是 XML？
·       XML
指可扩展标记语言（EXtensible MarkupLanguage）。
·       XML
是一种很像HTML的标记语言。
·       XML
的设计宗旨是传输数据，而不是显示数据。
·       XML
标签没有被预定义。您需要自行定义标签。
·       XML
被设计为具有自我描述性。
·       XML
是 W3C
的推荐标准。

XML 和 HTML
之间的差异
XML 不是 HTML
的替代。
XML 和 HTML
为不同的目的而设计：
·       XML
被设计用来传输和存储数据，其焦点是数据的内容。
·       HTML
被设计用来显示数据，其焦点是数据的外观。
HTML 旨在显示信息，而 XML
旨在传输信息。

XML 不会做任何事情
也许这有点难以理解，但是 XML
不会做任何事情。XML
被设计用来结构化、存储以及传输信息。
下面实例是 Jani
写给 Tove 的便签，存储为 XML：
ToveJaniReminderDon’t
forget me this weekend!
上面的这条便签具有自我描述性。它包含了发送者和接受者的信息，同时拥有标题以及消息主体。
但是，这个 XML
文档仍然没有做任何事情。它仅仅是包装在 XML
标签中的纯粹的信息。我们需要编写软件或者程序，才能传送、接收和显示出这个文档。

通过 XML
您可以发明自己的标签
上面实例中的标签没有在任何 XML
标准中定义过（比如
和 ）。这些标签是由 XML
文档的创作者发明的。
这是因为 XML
语言没有预定义的标签。
HTML 中使用的标签都是预定义的。HTML
文档只能使用在 HTML
标准中定义过的标签（如

、

等等）。
XML 允许创作者定义自己的标签和自己的文档结构。

XML 不是对 HTML
的替代
XML 是对 HTML
的补充。
XML 不会替代 HTML，理解这一点很重要。在大多数 Web
应用程序中，XML
用于传输数据，而 HTML
用于格式化并显示数据。
对 XML 最好的描述是：
XML 是独立于软件和硬件的信息传输工具。

XML 是 W3C
的推荐标准
XML 于 1998
年 2
月 10 日成为 W3C
的推荐标准。
如需了解有关 W3C XML
活动的更多信息，请访问我们的 W3C教程。

XML 无所不在
目前，XML 在 Web
中起到的作用不会亚于一直作为 Web
基石的 HTML。
XML 是各种应用程序之间进行数据传输的最常用的工具。
XML 树结构

XML 文档形成了一种树结构，它从"根部"开始，然后扩展到"枝叶"。

一个 XML
文档实例
XML 文档使用简单的具有自我描述性的语法：

<?xmlversion="1.0"encoding="UTF-8"?>ToveJaniReminderDon't

forget me this weekend!
第一行是 XML
声明。它定义 XML
的版本（1.0）和所使用的编码（UTF-8 :
万国码,
可显示各种语言）。
下一行描述文档的根元素（像在说：“本文档是一个便签”）：

接下来 4 行描述根的 4
个子元素（to, from, heading
以及 body）：
ToveJaniReminderDon’t
forget me this weekend!
最后一行定义根元素的结尾：

您可以假设，从这个实例中，XML
文档包含了一张 Jani
写给 Tove
的便签。
XML 具有出色的自我描述性，您同意吗？

XML 文档形成一种树结构
XML 文档必须包含根元素。该元素是所有其他元素的父元素。
XML 文档中的元素形成了一棵文档树。这棵树从根部开始，并扩展到树的最底端。
所有的元素都可以有子元素：
…
父、子以及同胞等术语用于描述元素之间的关系。父元素拥有子元素。相同层级上的子元素成为同胞（兄弟或姐妹）。
所有的元素都可以有文本内容和属性（类似 HTML中）。

实例：

上图表示下面的 XML
中的一本书：
XML 文档实例
<bookcategory=“COOKING”><titlelang=“en”>Everyday
ItalianGiada
De Laurentiis200530.00<bookcategory=“CHILDREN”><titlelang=“en”>Harry
PotterJ K.
Rowling200529.99<bookcategory=“WEB”><titlelang=“en”>Learning
XMLErik T.
Ray200339.95
实例中的根元素是 。文档中的所有
元素都被包含在
中。
元素有 4
个子元素：

XML 的语法规则很简单，且很有逻辑。这些规则很容易学习，也很容易使用。

XML 文档必须有根元素
XML 必须包含根元素，它是所有其他元素的父元素，比如以下实例中 root
就是根元素：
…
以下实例中 note
是根元素：

<?xmlversion="1.0"encoding="UTF-8"?>ToveJaniReminderDon't

forget me this weekend!

XML 声明
XML 声明文件的可选部分，如果存在需要放在文档的第一行，如下所示：

<?xml version="1.0" encoding="utf-8"?>

以上实例包含 XML
版本（<p=""><>
UTF-8 也是 HTML5, CSS, JavaScript, PHP,
和 SQL
的默认编码。

所有的 XML
元素都必须有一个关闭标签
在 HTML 中，某些元素不必有一个关闭标签：

This is a paragraph.

在 XML 中，省略关闭标签是非法的。所有元素都必须有关闭标签：

This is a paragraph.

注释：从上面的实例中，您也许已经注意到 XML
声明没有关闭标签。这不是错误。声明不是 XML
文档本身的一部分，它没有关闭标签。

XML 标签对大小写敏感
XML 标签对大小写敏感。标签
与标签
是不同的。
必须使用相同的大小写来编写打开标签和关闭标签：

这是错误的
这是正确的

注释：打开标签和关闭标签通常被称为开始标签和结束标签。不论您喜欢哪种术语，它们的概念都是相同的。

XML 必须正确嵌套
在 HTML 中，常会看到没有正确嵌套的元素：

This text is bold and italic

在 XML 中，所有元素都必须彼此正确地嵌套：

This text is bold and italic

在上面的实例中，正确嵌套的意思是：由于
元素是在
元素内打开的，那么它必须在
元素内关闭。

XML 属性值必须加引号
与 HTML 类似，XML
元素也可拥有属性（名称/值的对）。
在 XML 中，XML
的属性值必须加引号。
请研究下面的两个 XML
文档。第一个是错误的，第二个是正确的：

Tove Jani Tove Jani

在第一个文档中的错误是，note
元素中的 date
属性没有加引号。

实体引用
在 XML 中，一些字符拥有特殊的意义。
如果您把字符 “<”
放在 XML 元素中，会发生错误，这是因为解析器会把它当作新元素的开始。
这样会产生 XML
错误：

if salary < 1000 then

为了避免这个错误，请用实体引用来代替"<"
字符：

if salary < 1000 then

在 XML 中，有 5
个预定义的实体引用：

<

<

less than

>

greater than

&

&

ampersand

'

’

apostrophe

"

"

quotation mark

注释：在 XML
中，只有字符 “<”
和 “&” 确实是非法的。大于号是合法的，但是用实体引用来代替它是一个好习惯。

XML 中的注释
在 XML 中编写注释的语法与 HTML
的语法很相似。

在 XML 中，空格会被保留
HTML 会把多个连续的空格字符裁减（合并）为一个：

HTML:

Hello Tove

Output:

Hello Tove

在 XML 中，文档中的空格不会被删减。

XML 以 LF
存储换行
在 Windows
应用程序中，换行通常以一对字符来存储：回车符（CR）和换行符（LF）。
在 Unix 和 Mac OSX
中，使用 LF
来存储新行。
在旧的 Mac
系统中，使用 CR 来存储新行。
XML 以 LF
存储换行
XML 验证

拥有正确语法的 XML
被称为"形式良好"的 XML。
通过 DTD 验证的XML是"合法"的
XML。

形式良好的 XML
文档
"形式良好"的 XML
文档拥有正确的语法。
在前面的章节描述的语法规则：
·       XML
文档必须有一个根元素
·       XML元素都必须有一个关闭标签
·       XML
标签对大小写敏感
·       XML
元素必须被正确的嵌套
·       XML
属性值必须加引号

<?xmlversion="1.0" encoding="ISO-8859-1"?> Tove Jani Reminder Don't forget me this weekend!  

验证 XML
文档
合法的 XML
文档是"形式良好"的 XML
文档，这也符合文档类型定义（DTD）的规则：

<?xmlversion="1.0" encoding="ISO-8859-1"?> Tove Jani Reminder Don't forget me this weekend! 在上面的实例中，DOCTYPE 声明是对外部 DTD 文件的引用。下面的段落展示了这个文件的内容。

XML DTD
DTD 的目的是定义 XML
文档的结构。它使用一系列合法的元素来定义文档结构：

<!ELEMENT to (#PCDATA)> <!ELEMENT from (#PCDATA)> <!ELEMENT heading (#PCDATA)> <!ELEMENT body (#PCDATA)>

]>
如果您想要学习 DTD，请在我们的首页查找
DTD 教程。

XML Schema
W3C 支持一种基于 XML
的 DTD
代替者，它名为 XML Schema：
xs:elementname=“note”

xs:complexType
xs:sequence
<xs:element name=“to” type=“xs:string”/>
<xs:element name=“from” type=“xs:string”/>
<xs:element name=“heading” type=“xs:string”/>
<xs:element name=“body” type=“xs:string”/>
</xs:sequence>
</xs:complexType>

</xs:element>
如果您想要学习 XML Schema，请在我们的首页查找
Schema 教程。

一个通用的 XML
验证器
为了帮助您检查 XML
文件的语法，我们创建了 XML
验证器，以便您对任何 XML
文件进行语法检查。
请看下一章
 
 
 
 
 
 
 
 
 
 
 
 
16：java常见的排序算法
分为以下几类
1.冒泡排序
public voidmaop(int a[]) {
for (int i = 0;i < a.length - 1; i++) {
for (int j = 0;j < a.length - 1 - i; j++) {
if (a[j] >a[j + 1]) {
int temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
for (int k = 0;k < a.length; k++) {
System.out.println(a[k]);
}
}
 
 
2.选择排序
    public void selectSort(int []
a) { 
        int n = a.length;  
        for(int k=0; k<n-1; k++) {  
            int min = k;  
            for(int i=k+1; i<n; i++) {
 
                if(a[i] < a[min]) {  
                    min= i;  
                } 
            } 
            if(k != min) {  
                int temp = a[k];  
                a[k]= a[min];  
                a[min]= temp;  
            } 
        } 
    } 
3.快速排序
   
        int[]a = {12,20,5,16,15,1,30,45,23,9};
        intstart = 0;
        intend = a.length-1;
        sort(a,start,end);
        for(inti = 0; i<a.length; i++){
             System.out.println(a[i]);
         }
        
     }
     
     publicstatic  void sort(int[] a,int low,int high){
         intstart = low;
         intend = high;
         intkey = a[low];
         
         
         while(end>start){
             //从后往前比较
             while(end>start&&a[end]>=key) //如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较
                 end–;
             if(a[end]<=key){
                 inttemp = a[end];
                 a[end]= a[start];
                 a[start]= temp;
             }
             //从前往后比较
             while(end>start&&a[start]<=key)//如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置
                start++;
             if(a[start]>=key){
                 inttemp = a[start];
                 a[start]= a[end];
                 a[end]= temp;
             }
         //此时第一次循环比较结束，关键值的位置已经确定了。左边的值都比关键值小，右边的值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用
         }
         //递归
         if(start>low)sort(a,low,start-1);//左边序列。第一个索引位置到关键值索引-1
         if(end<high)sort(a,end+1,high);//右边序列。从关键值索
 
 
 
4二分法查找
    public class DichotomySearch {
     public
static void main(String[] args) {
       int[]arr =
new int[] { 12, 23, 34, 45, 56, 67, 77, 89, 90 };
      System.out.println(search(arr, 12));
      System.out.println(search(arr, 45));
      System.out.println(search(arr, 67));
      System.out.println(search(arr, 89));
      System.out.println(search(arr, 99));
   }
   public
static int search(int[]arr,
int key) {
       intstart = 0;
       intend = arr.length - 1;
       while(start <= end) {
          int middle = (start + end) / 2;
          if (key < arr[middle]) {
              end = middle - 1;
          } else
if (key > arr[middle]) {
              start = middle + 1;
          } else {
              return middle;
          }
      }
       return -1;
   }
}
5直接插入排序
 public class InsertionSort {
    public static void insertionSort(int[] a) {
        int tmp;
        for (int i = 1; i <a.length; i++) {
            for (int j = i; j > 0;j–) {
                if (a[j] < a[j - 1]) {
                    tmp= a[j - 1];
                    a[j- 1] = a[j];
                    a[j]= tmp;
                }
            }
        }
    }
    public static void main(String[] args) {
        int[]a = { 49, 38, 65, 97, 76, 13, 27, 50 };
        insertionSort(a);
        for (int i : a)
            System.out.print(i+ " ");
    }
}
希尔排序
 public void shellSort(int[] list) {
    int gap = list.length / 2;
    while (1 <= gap) {
        // 把距离为 gap 的元素编为一个组，扫描所有组
        for (int i = gap; i < list.length; i++) {
            int j = 0;
            int temp = list[i];
 
            // 对距离为 gap 的元素组进行排序
            for (j = i - gap; j >= 0 && temp < list[j]; j = j - gap) {
                list[j + gap] = list[j];
            }
            list[j + gap] = temp;
        }
      System.out.format(“gap = %d:\t”, gap);
        printAll(list);
        gap = gap / 2; // 减小增量
 }
}
17:Java异常基础知识
 
public static void main(String[]
args)throws Exception{
/int a =divide(3, 0);
System.out.println(a);/
/try{
int a=4/0;
}catch(Exception e) {
System.out.print(“执行到这里”);
}finally{
System.out.print(“不管是否捕捉到异常，此代码执行”);
}/
int a=5/0;
/算术异常类：ArithmeticExecption
空指针异常类：NullPointerException
类型强制转换异常：ClassCastException
数组负下标异常：NegativeArrayException
数组下标越界异常：ArrayIndexOutOfBoundsException
违背安全原则异常：SecturityException
文件已结束异常：EOFException
文件未找到异常：FileNotFoundException
字符串转换为数字异常：NumberFormatException
操作数据库异常：SQLException
输入输出异常：IOException
方法未找到异常：NoSuchMethodException/
}
//报错,语法本身有错
/public staticint divide(int a, int b) {
try{
return a % b;
}catch(Exceptione){
e.printStackTrace();
}
}/
//报错
/public staticint divide(int a, int b) throws Exception {
return a % b;
}/
//
}
18：内部类的基础知识
内部类是指一个外部类的外面再去定义一个类，内部类作为外部类的一个成员，并依附于外部类而存在，内部类继承自某个类或某个接口，操作创建外围类的对象。分为四种：静态，成员，局部，匿名。
 
 
 
 
 
 
 
 
 
 
 
 
 
 
19：
 
 
 
20：Javaweb基础知识
一：安装javaweb运行环境
应用程序一般分两种，C/S，B/S,其中C/S是客户端/服务器端应用程序，也就是说这种应用程序一般独立运行。另外B/S就是浏览器/服务器端应用程序，一个web’应用程序包括web客户端和web服务器端两部分，其中客户端通常指的是用户机上的浏览器，客户端不需要开发任何的界面，统一采用浏览器即可。Web服务器是一台或多台可运行web应用程序的计算机，通常在浏览器上输入的网络地址，就是web服务器的地址。
开发工具jdk，它提供了编译Java程序和运行Java程序的环境，jdk包括jre，api。类库等开发必备的东西，
Tomcat服务器，web服务器的工作原理：
1，web浏览器向一个特定的web服务器发出web页面请求。
2，web服务器接收到请求之后，寻求所请求的web页面，执行相应的功能。
3，将用户请求的最后结果以web页面形式发送到客户的web浏览器上。
Tomcat中包含bin,conf,lib,logs,temp,webapps,work.等子文件。双击bin目录中的startup.bat,启动tomcat，在浏览器上输入http://localhost:8080访问tomcat，其中8080表示tomcat默认端口号。
Mysql数据库和myeclispe。
二：jsp页面元素
1.jsp指令元素page指令，include指令，taglib指令。
其中page指令包含
language,extends,session,buffer,authflush,isThraedflush,info,errorPage,isErrorPage,cotenttype
等元素。
Include指示包含文件，taglib指示jsp页面使用的标签库。
2.jsp脚本元素用来插入java代码，这些Java代码将出现在由当前jsp页面生成的Servelt中。
<%!declaration%> 声明脚本元素
<%=expression%> 表达式
<%scriptlet%>脚本
声明：
<%!  
     Stringusename=”shixnfa”
     Stringpassword=”933032”
%>
<%!
  Publicstatic int tt(int n){
if(n0){
  return 0;
   }
else if(n1){
return 1;
}
else{
return tt(n-2)+tt(n-1);
}
}
%>
表达式：

Currenttime:<%=new java.util.Date()%> 脚本元素： <%  Stringname[]={“tom”,”lily”,”wangming”,”zhangsan”};  For(inti=0;i

---

本文来自 言寡 的CSDN 博客 ，全文地址请点击：https://blog.csdn.net/qq_21406125/article/details/72808790?utm_source=copy