Java

最新推荐文章于 2024-01-03 04:00:00 发布

言寡

最新推荐文章于 2024-01-03 04:00:00 发布

阅读量538

点赞数 1

本文链接：https://blog.csdn.net/qq_21406125/article/details/72808790

版权

Java基础知识回顾：

1：数据的基础类型

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("双方全部不成立才输出");

}

依次输出

双方成立才输出

其中一个条件成立就输出

双方全部不成立才输出

比较运算符：大于小于等于

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);

这个运算的作用相当于：9*4，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(i==2){

continue;

}

System.out.println(i);

if(i==4){

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(r);

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(c);

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);

List<Person>list = new ArrayList<Person>();

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<String> list=new ArrayList<String>();

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<Integer>();

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"?><note><to>Tove</to><from>Jani</from><heading>Reminder</heading><body>Don't forget me this weekend!</body></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：

<note><to>Tove</to><from>Jani</from><heading>Reminder</heading><body>Don't forget me this weekend!</body></note>

上面的这条便签具有自我描述性。它包含了发送者和接受者的信息，同时拥有标题以及消息主体。

但是，这个 XML 文档仍然没有做任何事情。它仅仅是包装在 XML 标签中的纯粹的信息。我们需要编写软件或者程序，才能传送、接收和显示出这个文档。

通过 XML 您可以发明自己的标签

上面实例中的标签没有在任何 XML 标准中定义过（比如 <to> 和 <from>）。这些标签是由 XML 文档的创作者发明的。

这是因为 XML 语言没有预定义的标签。

HTML 中使用的标签都是预定义的。HTML 文档只能使用在 HTML 标准中定义过的标签（如 <p>、<h1> 等等）。

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"?><note><to>Tove</to><from>Jani</from><heading>Reminder</heading><body>Don't forget me this weekend!</body></note>

第一行是 XML 声明。它定义 XML 的版本（1.0）和所使用的编码（UTF-8 : 万国码, 可显示各种语言）。

下一行描述文档的根元素（像在说："本文档是一个便签"）：

<note>

接下来 4 行描述根的 4 个子元素（to, from, heading 以及 body）：

<to>Tove</to><from>Jani</from><heading>Reminder</heading><body>Don't forget me this weekend!</body>

最后一行定义根元素的结尾：

</note>

您可以假设，从这个实例中，XML 文档包含了一张 Jani 写给 Tove 的便签。

XML 具有出色的自我描述性，您同意吗？

XML 文档形成一种树结构

XML 文档必须包含根元素。该元素是所有其他元素的父元素。

XML 文档中的元素形成了一棵文档树。这棵树从根部开始，并扩展到树的最底端。

所有的元素都可以有子元素：

父、子以及同胞等术语用于描述元素之间的关系。父元素拥有子元素。相同层级上的子元素成为同胞（兄弟或姐妹）。

所有的元素都可以有文本内容和属性（类似 HTML中）。

实例：

上图表示下面的 XML 中的一本书：

XML 文档实例

<bookstore><bookcategory="COOKING"><titlelang="en">Everyday Italian</title><author>Giada De Laurentiis</author><year>2005</year><price>30.00</price></book><bookcategory="CHILDREN"><titlelang="en">Harry Potter</title><author>J K. Rowling</author><year>2005</year><price>29.99</price></book><bookcategory="WEB"><titlelang="en">Learning XML</title><author>Erik T. Ray</author><year>2003</year><price>39.95</price></book></bookstore>

实例中的根元素是 <bookstore>。文档中的所有 <book> 元素都被包含在 <bookstore> 中。

XML 语法规则

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

XML 文档必须有根元素

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

以下实例中 note 是根元素：

<?xmlversion="1.0"encoding="UTF-8"?><note><to>Tove</to><from>Jani</from><heading>Reminder</heading><body>Don't forget me this weekend!</body></note>

XML 声明

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

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

以上实例包含 XML 版本（<p=""><>

UTF-8 也是 HTML5, CSS, JavaScript, PHP, 和 SQL 的默认编码。

所有的 XML 元素都必须有一个关闭标签

在 HTML 中，某些元素不必有一个关闭标签：

<p>This is a paragraph.

<br>

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

<p>This is a paragraph.</p>

<br />

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

XML 标签对大小写敏感

XML 标签对大小写敏感。标签 <Letter> 与标签 <letter> 是不同的。

必须使用相同的大小写来编写打开标签和关闭标签：

<Message>这是错误的</message>

<message>这是正确的</message>

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

XML 必须正确嵌套

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

<b><i>This text is bold and italic</b></i>

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

<b><i>This text is bold and italic</i></b>

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

XML 属性值必须加引号

与 HTML 类似，XML 元素也可拥有属性（名称/值的对）。

在 XML 中，XML 的属性值必须加引号。

请研究下面的两个 XML 文档。第一个是错误的，第二个是正确的：

<note date=12/11/2007>

<to>Tove</to>

<from>Jani</from>

</note>

<note date="12/11/2007">

<to>Tove</to>

<from>Jani</from>

</note>

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

实体引用

在 XML 中，一些字符拥有特殊的意义。

如果您把字符 "<" 放在 XML 元素中，会发生错误，这是因为解析器会把它当作新元素的开始。

这样会产生 XML 错误：

<message>if salary < 1000 then</message>

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

<message>if salary &lt; 1000 then</message>

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

<	<	less than
>	>	greater than
&	&	ampersand
'	'	apostrophe
"	"	quotation mark

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

XML 中的注释

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

<!-- This is a comment -->

在 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"?>
<note>
<to>Tove</to>
<from>Jani</from>
<heading>Reminder</heading>
<body>Don't forget me this weekend!</body>
</note>

验证 XML 文档

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

<?xmlversion="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE note SYSTEM"Note.dtd">
<note>
<to>Tove</to>
<from>Jani</from>
<heading>Reminder</heading>
<body>Don't forget me this weekend!</body>
</note>

在上面的实例中，DOCTYPE 声明是对外部 DTD 文件的引用。下面的段落展示了这个文件的内容。

XML DTD

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

<!DOCTYPEnote
[
<!ELEMENT note (to,from,heading,body)>
<!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服务器的地址。