Java，
Java，
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("双方全部不成立才输出");
}
依次输出
双方成立才输出
其中一个条件成立就输出
双方全部不成立才输出
比较运算符：大于小于等于
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);
这个运算的作用相当于：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 文档中的元素形成了一棵文档树。这棵树从根部开始，并扩展到树的最底端。
所有的元素都可以有子元素：
<root><child><subchild>.....</subchild></child></root>
父、子以及同胞等术语用于描述元素之间的关系。父元素拥有子元素。相同层级上的子元素成为同胞（兄弟或姐妹）。
所有的元素都可以有文本内容和属性（类似 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> 中。
<book> 元素有 4 个子元素：<title>、<author>、<year>、<price>
XML 语法规则
XML 的语法规则很简单，且很有逻辑。这些规则很容易学习，也很容易使用。
XML 文档必须有根元素
XML 必须包含根元素，它是所有其他元素的父元素，比如以下实例中 root 就是根元素：
<root><child><subchild>.....</subchild></child></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 < 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服务器的地址。
开发工具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(n==0){
return 0;
}
else if(n==1){
return 1;
}
else{
return tt(n-2)+tt(n-1);
}
}
%>
表达式：
<body>
Currenttime:<%=new java.util.Date()%>
</body>
脚本元素：
<%
Stringname[]={“tom”,”lily”,”wangming”,”zhangsan”};
For(inti=0;i<name.length;i++){%>
<tr>
<td><%=name[i]%></td>
<tr>
<%}
%>
3.jsp动作元素
主要包括以下几种：
Jsp:include 在页面被请求时引入一个文件。
<jsp:includepage=”URL” flush=”true”/>
Jsp:usebean 寻找或实例化一个javabean。
<jsp:useBeanid=”name” class=”package.class”/>
Jsp:setProperty 设置javaBean的属性
相关文章
- 暂无相关文章
用户点评