java概念1

public static void main(String[] args) {//其中[]也可以写在args后面，args也可以随便写成其他字母，例如asdfjkl，这里args只是一个形式参数，所以可以随便改变

Java标识符命名规则：

u       标识符由字母、下划线、美元符或数字组成。

u       标识符应以字母、下划线、美元符开头。

u       标识符大小写敏感，长度无限制。

合法标识符	非法标识符
HelloWorld	Class（不能为关键字）
DataClass	DataClass#（不能为#）
_123	12.3（不能为数字）
＄xx	Hello World（不能有空格）

所有Java关键字都是小写字母。

（1）           变量的分类

u   按被声明的位置分：

l       局部变量：方法或语句块内部定义的变量，方法体内部是指与方法对应的大括号内部。

l       成员变量：方法外部、类的内部定义的变量。

u   按所属数据类型分：

l       基本数据类型变量。

l       引用数据类型变量。

 

数据类型

基本数据类型

引用数据类型

布尔型（boolean）

整数类型（byte、short、int、long）

浮点类型（float、double）

数组

接口（interface）

字符型（char）

数值型

u       Java字符采用Unicode编码，每个字符占两个字节，因而可用十六进制编码形式表示。例如：char a = ‘b’，char c = ‘国’（char占两个字节）

char c = ‘\u0061’  其中Unicode是全球语言统一编码。

注：case语句后一般要加break语句；多个case可以合并在一起；default可以省略，但不推荐这样做；Java中swith语句只能探测int类型值。

u     switch语句举例：

public class TestSwitch {

   public static void main(String[] args) {

       int i = 8;

       switch(i) {

           case 8 :

           case 3 :

           case 2 :

               System.out.println("C");

               break;

           case 9 :

               System.out.println("D");

               break;

           default:

               System.out.println("error");

       }

   }

}

	修饰符	类内部	同一个包	子类	任何地方
	private	√
	Default/friendly	√	√
	protected	√	√	√
	public	√	√	√	√
运算符	说明
<<	左移位，在低位处补0
>>	右移位，若为正数则高位补0，若为负数则高位补1
>>>	无符号右移位，无论正负都在高位补0
&	与（AND），对两个整型操作数中对应位执行布尔代数，两个位都为1时输出1，否则0。
|	或（OR），对两个整型操作数中对应位执行布尔代数，两个位都为0时输出0，否则1。
~	非（NOT），一元运算符。
^	异或（XOR），对两个整型操作数中对应位执行布尔代数，两个位相等0，不等1。
<<=	左移位赋值。
>>=	右移位赋值。
>>>=	无符号右移位赋值。
&=	按位与赋值。
|=	按位或赋值。
^=	按位异或赋值。

一般情况下编程只需要用&&就好了，比如

boolean a = true;

boolean b = false;

boolean c = a&&b;

那么b的值就是false；

 

而&是位操作符，例如：

int a = 2;

int b = 3;

2的二进制为10；3的二进制为11；

那么

int c = a&b;

c的值就为10&11=10,所以c等于2。

3. 常见的两种xml解析技术是什么? 区别是什么? （4分） 答：常见的两种有：SAX和DOM。  

区别：SAX 是一种事件驱动的xml解析方式。每次访问一个xml文件中的某个节点的时候，sax就会搜索一遍xml文件，在找到相应的节点后就会触发一个事件来处理请求。只读            DOM是一种基于树状的查找方式。

DOM会将xml解析成一棵树，存在内存中。开发者可以通过查找树的节点来取得文件的内容或者修改内容。可读写。

 

单例模式用法很多，下面算是比较通用的一种：

class Singleton {

  private static Singleton s;

  private Singleton(){

   System.out.println("A Singleton Model example");

  }

  public static Singleton getSigleton()

  {

   if(s==null)s=new Singleton();

   return s;

  }

}

这种情况只能使用 Singleton.getSigleton()获得一个实例，因为构造方法是private，所以不可能在别的函数里new()实例

Singleton意图   保证一个类仅有一个实例，并提供一个访问它的全局访问点。 2. 动机   对一些类来说，只有一个实例是很重要的。虽然系统中可以有许多打印机，但却只应该有一个打印假脱机（ printer spooler），只应该有一个文件系统和一个窗口管理器。一个数字滤波器只能有一个A / D转换器。一个会计系统只能专用于一个公司。   我们怎么样才能保证一个类只有一个实例并且这个实例易于被访问呢？一个全局变量使得一个对象可以被访问，但它不能防止你实例化多个对象。一个更好的办法是，让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可以被创建（通过截取创建新对象的请求），并且它可以提供一个访问该实例的方法。这就是Singleton模式。

1、Java 多态的实现

答案：继承、重载、覆盖

2、String 类是否能被继承

答案：不能，是个final 修饰的类。

5、谈谈final, finally, finalize 的区别。 

答案：final?修饰符（关键字）如果一个类被声明为 final ，意味着它不能再

派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract

的，又被声明为 final 的。将变量或方法声明为 final ，可以保证它们在使用

中不被改变。被声明为final 的变量必须在声明时给定初值，而在以后的引用

中只能读取，不可修改。被声明为final 的方法也同样只能使用，不能重载 

finally? 再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个

异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块

（如果有的话）。 

finalize?方法名。Java  技术允许使用 finalize() 方法在垃圾收集器将

对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定

这个对象没有被引用时对这个对象调用的。它是在 Object  类中定义的，因此

所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其

他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用

的。

7、HashMap和Hashtable 的区别。 

答案：都属于Map 接口的类，实现了将惟一键映射到特定的值上。 

HashMap  类没有分类或者排序。它允许一个 null 键和多个 null 值。 

Hashtable  类似于 HashMap ，但是不允许 null 键和 null 值。它也比

HashMap  慢，因为它是同步的。

13、try {}里有一个return 语句，那么紧跟在这个try 后的finally {}

里的code 会不会被执行，什么时候被执行，在return 前还是后? 

答案：会执行，在return 前执行。

15、说出ArrayList,Vector,  LinkedList 的存储性能和特性

答案：ArrayList 和Vector 都是使用数组方式存储数据，此数组元素数大于

实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插

入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector

由于使用了synchronized方法（线程安全），通常性能上较ArrayList 差，

而LinkedList 使用双向链表实现存储，按序号索引数据需要进行前向或后向

遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。

16、多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么? 

答：多线程有两种实现方法，分别是继承Thread 类与实现Runnable 接口 

同步的实现方面有两种，分别是synchronized,wait与notify

20、forward  和redirect 的区别

答案：forward是服务器请求资源，服务器直接访问目标地址的URL ，把那个

URL 的响应内容读取过来，然后把这些内容再发给浏览器，浏览器根本不知道服

务器发送的内容是从哪儿来的，所以它的地址栏中还是原来的地址。

redirect 就是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个

地址，一般来说浏览器会用刚才请求的所有参数重新请求，所以

session,request 参数都可以获取。

3、储存过程和函数的区别是什么

答案：存储过程是用户定义的一系列SQL 语句的集合，涉及特定表或其他对象

的任务，用户可以调用存储过程。而函数通常是数据库已经定义的方法，它接受

参数并返回某种类型的值，并且不涉及特定用户表。

4 mysql操作

找出表中年龄最大的一行数：

mysql> select * from test where age=(select max(age) from test);

mysql> select * from test group by age having age=(select max(age) from test);

mysql> select * from test where age>=all(select age from test);

mysql> select * from test group by age having age>=all(select age from test);

找出age重复的行：

mysql> select * from test where age in(select age from test group by age having(count(age)>1));

10、为了防止在查询记录的时候被其他用户更改记录，应该采用什么方法？如

何用查询语句实现该方法？

答案：添加一个“时间戳”类型的字段就可以了。 Timestamp 这种数据类型会

根据当前时间自动产生一个时间字符串，确保这些数在数据库中是唯一的。

Timetamp 一般用做给表行加版本戳的机制，存储大小为8 字节。一个标志能

有一个timestamp 列。每次插入或更新包含timestamp 列的行时，

timestamp 列中的值均会更新。这一属性使timestamp 列不适合为关键是用，

尤其是不能作为主键是用。对行的任何更新都会更改 timestamp 值，从而更改

键值。

2、XML 文档定义有几种形式？它们之间有何本质区别？

两种形式 dtd,schema

本质区别:schema本身是xml 的,可以被XML 解析器解析(这也是从DTD 上发

展schema 的根本目的)

2、电子邮件传输协议是？ SMTP

3、文件传输是基于哪种协议的？ TCP

4、一个C 类网络最多能容纳多少台主机？ 254

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的以及动态调用对象的方法的功能称为java语言的反射机制。

Java反射机制主要提供了以下功能：在运行时判定任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判定任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。

 

1 冒泡排序

package com.cn.sort;

public class BubbleSort{

    public void bubbleSort(int[] array){

       int temp;

       boolean flag=true;

       for(int i=0;i<array.length-1&&flag==true;i++){//比较时为i<array.length-1，因为有两个数在比较

           flag=false;

           for(int j=0;j<array.length-i-1;j++){

              if(array[j]>array[j+1]){//如果要从大到小排序只需改变此处顺序即可

                  temp=array[j+1];

                  array[j+1]=array[j];

                  array[j]=temp;

                  flag=true;

              }

           }

           //打印每趟排序结果

           for(int m=0;m<=array.length-1;m++){//输出时为i<=array.length-1

              System.out.print(array[m]+"\t");

           }

           System.out.println();

       }

    }

   

    public static void main(String[] args){

       BubbleSort bubbleSort=new BubbleSort();

       int[] array={5,69,12,3,56,789,2,5648,23};

       bubbleSort.bubbleSort(array);

       System.out.println("排序后结果为：");

       for(int i=0;i<=array.length-1;i++){//输出时为i<=array.length-1

           System.out.print(array[i]+"\t");

       }

    }

}

2         选择排序

package com.cn.sort;

 

public class SelectionSort {

    public void selectionSort(int[] array){

       int temp;

       for(int i=0;i<array.length-1;i++){

           for(int j=i+1;j<=array.length-1;j++){//第i个和第j个比较j可以取到最后一位，所以要用j<=array.length-1

              if(array[i]>array[j]){//注意和冒泡排序的区别，这里是i和j比较。

                  temp=array[i];

                  array[i]=array[j];

                  array[j]=temp;

              }

           }

           //打印每趟排序结果

           for(int m=0;m<=array.length-1;m++){

              System.out.print(array[m]+"\t");

           }

           System.out.println();

       }

    }

   

    public static void main(String[] args){

       SelectionSort selectionSort=new SelectionSort();

       int[] array={5,69,12,3,56,789,2,5648,23};

       selectionSort.selectionSort(array);

       for(int m=0;m<=array.length-1;m++){

           System.out.print(array[m]+"\t");

       }

    }

}

3        插入排序

package com.cn.sort;

 

public class InsertSort {

    public void insertSort(int[] array,int first,int last){

       int temp,i,j;

       for(i=first+1;i<=last-1;i++){//默认以第一个数为有序序列，后面的数为要插入的数。

           temp=array[i];

           j=i-1;

           while(j>=first&&array[j]>temp){//从后进行搜索如果搜索到的数小于temp则该数后移继续搜索，直到搜索到小于或等于temp的数即可

              array[j+1]=array[j];

              j--;

           }

           array[j+1]=temp;

           //打印每次排序结果

           for(int m=0;m<=array.length-1;m++){

              System.out.print(array[m]+"\t");

           }

           System.out.println();

        }

    }

   

    public static void main(String[] args){

       InsertSort insertSort=new InsertSort();

       int[] array={5,69,12,3,56,789,2,5648,23};

       insertSort.insertSort(array, 0, array.length);//注意此处是0-9而不是0-8

       for(int i=0;i<=array.length-1;i++){

           System.out.print(array[i]+"\t");

       }

    }

}

 

4         快速排序

package com.cn.sort;

 

public class QuickSort {

    public int partition(int[] sortArray,int low,int height){

       int key=sortArray[low];//刚开始以第一个数为标志数据

       while(low<height){

           while(low<height&&sortArray[height]>=key)

              height--;//从后面开始找，找到比key值小的数为止

           sortArray[low]=sortArray[height];//将该数放到key值的左边

           while(low<height&&sortArray[low]<=key)

              low++;//从前面开始找，找到比key值大的数为止

           sortArray[height]=sortArray[low];//将该数放到key值的右边

       }

       sortArray[low]=key;//把key值填充到low位置，下次重新找key值

       //打印每次排序结果

       for(int i=0;i<=sortArray.length-1;i++){

           System.out.print(sortArray[i]+"\t");

       }

       System.out.println();

       return low;

    }

    public void sort(int[] sortArray,int low,int height){

       if(low<height){

           int result=partition(sortArray,low,height);

           sort(sortArray,low,result-1);

           sort(sortArray,result+1,height);

       }

    }

   

    public static void main(String[] args){

       QuickSort quickSort=new QuickSort();

       int[] array={5,69,12,3,56,789,2,5648,23};

       for(int i=0;i<=array.length-1;i++){

           System.out.print(array[i]+"\t");

       }     

       System.out.println();

       quickSort.sort(array,0,8);

       for(int i=0;i<=array.length-1;i++){

           System.out.print(array[i]+"\t");

       }

    }

}

5         希尔排序

package com.cn.sort;

 

public class ShellSort {

    public void shellSort(int[] array, int n){

       int i, j, gap;

       int temp;

        for (gap=n/2;gap>0;gap/=2){//计算gap大小

            for(i=gap;i<n;i++){//将数据进行分组

                for(j=i-gap;j>=0&&array[j]>array[j+gap];j-=gap){//对每组数据进行插入排序

                  temp=array[j];

                  array[j]=array[j+gap];

                  array[j+gap]=temp;

                }

                //打印每趟排序结果

              for(int m=0;m<=array.length-1;m++){

                  System.out.print(array[m]+"\t");

              }

              System.out.println();

            }

        }

    }

   

    public static void main(String[] args){

       ShellSort shellSort=new ShellSort();

       int[] array={5,69,12,3,56,789,2,5648,23};

       shellSort.shellSort(array, array.length);//注意为数组的个数

       for(int m=0;m<=array.length-1;m++){

           System.out.print(array[m]+"\t");

       }

    }

}

6         归并排序

public class MergeSortTest { 

    public void sort(int[] array, int left, int right) { 

        if (left >= right) 

            return; 

        // 找出中间索引 

        int center = (left + right) / 2; 

        // 对左边数组进行递归 

        sort(array, left, center); 

        // 对右边数组进行递归 

        sort(array, center + 1, right); 

        // 合并 

        merge(array, left, center, right); 

        //打印每次排序结果

        for (int i = 0; i < array.length; i++) { 

            System.out.print(array[i] + "\t"); 

        } 

        System.out.println(); 

 

    } 

 

    /**

     * 将两个数组进行归并，归并前面2个数组已有序，归并后依然有序

     * 

     * @param array

     *            数组对象

     * @param left

     *            左数组的第一个元素的索引

     * @param center

     *            左数组的最后一个元素的索引，center+1是右数组第一个元素的索引

     * @param right

     *            右数组最后一个元素的索引

     */ 

    public void merge(int[] array, int left, int center, int right) { 

        // 临时数组 

        int[] tmpArr = new int[array.length]; 

        // 右数组第一个元素索引 

        int mid = center + 1; 

        // third 记录临时数组的索引 

        int third = left; 

        // 缓存左数组第一个元素的索引 

        int tmp = left; 

        while (left <= center && mid <= right) { 

            // 从两个数组中取出最小的放入临时数组 

            if (array[left] <= array[mid]) { 

                tmpArr[third++] = array[left++]; 

            } else { 

                tmpArr[third++] = array[mid++]; 

            } 

        } 

        // 剩余部分依次放入临时数组（实际上两个while只会执行其中一个） 

        while (mid <= right) { 

            tmpArr[third++] = array[mid++]; 

        } 

        while (left <= center) { 

            tmpArr[third++] = array[left++]; 

        } 

        // 将临时数组中的内容拷贝回原数组中 

        // （原left-right范围的内容被复制回原数组） 

        while (tmp <= right) { 

            array[tmp] = tmpArr[tmp++]; 

        } 

    } 

   

    public static void main(String[] args) { 

        int[] array = new int[] { 5,69,12,3,56,789,2,5648,23 };

        MergeSortTest mergeSortTest=new MergeSortTest();

        mergeSortTest.sort(array, 0, array.length - 1);

        System.out.println("排序后的数组："); 

       for(int m=0;m<=array.length-1;m++){

           System.out.print(array[m]+"\t");

       }

    } 

} 

7        二分法查找

package com.cn.search;

 

import java.util.Scanner;

 

public class BinarySearch {

 

    public void binarySearch(int[] array,int search){

       int lower=0,temp=array.length-1,index=-1,currentValue=0;

       while(lower<=temp){

           index=(lower+temp)/2;

           currentValue=array[index];

           if(currentValue==search)

              break;

           else if(currentValue>search)

              temp=index-1;

           else lower=index+1;

       }

       if(lower<=temp)

           System.out.println("你要查找的数为 "+currentValue+"。");

       else

           System.out.println("你要查找的数不存在。");

    }

    public static void main(String[] args){

       BinarySearch binarySearch=new BinarySearch();

       int[] array={1,5,6,9,12,23,45,56,78,89,112,123};

       System.out.println("Input the search number:");

       Scanner scanner=new Scanner(System.in);

       int search=scanner.nextInt();

       binarySearch.binarySearch(array, search);

    }

}

 

转载于:https://my.oschina.net/mkh/blog/83722