1.char数据类型在在内存中是以数据存储的，范围是0~65535之间，没一个数都影射 一个字符,参与运算则以数字显示，不参与运算一字符形式显示。
eg:package org.west;
public class RabbitNum {
public static void main(String[] args) {
char c=97;
System.out.println("不参与运算："+c);
System.out.println("参与运算："+(c+7));
}
}
例中程序输出结果为：不参与运算：a
参与运算：104
2.byte,short,char变量一旦 参与运算，编译器就会将运算的结果转化为int型。
eg:package org.west;
public class RabbitNum {
Public static void main(String[] args) {
byte b1=1;
byte b2=2;
//byte b3=b1+b2;//此时报错
byte b3=(byte)(b1+b2);//强制转换
char a1=4;
char a2=3;
//char a3=a1+a2;//此时报错
char a3=(char)(a1+a2);//强制转换
System.out.println(b3);
System.out.println(a3);
}
}
(short与byte，char原理相同，故不再举例)
3.当给整数byte，short，char型变量以“直接常量”的方式赋值时，只要这些“直接常量”没有超过这些数据类型的范围时，都可以直接赋值。
eg:byte a=2;
二.方法
1.方法格式：
修饰符 返回值类型 方法名（形式参数列表）{
执行语句
..........
Return 返回值
}
对于上述语法格式具体说明如下：
·修饰符：有静态修饰符static，还有最终修饰符final等,对方法进行修饰。
·返回值类型：用于限定方法返回值的数据类型。
·参数类型：用于限定调用方法时传入的参数数据类型。
·参数名：是一个变量，用于接收调用方法是传入的数据。
·return关键字：用于结束方法以及返回方法指定类型的值。
·返回值：被return语句返回的值，该值会返回给调用者。
2.参数的两种形式：
·形式参数：在方法定义时用于接收外界输入的数据。
·实际参数(实参)：调用方法时实际传给方法的数据。
3.方法参数的传递：（1）传基本数据类型，方法接收到的实际上是这个值得拷贝。
（2）传引用类型的参数是，实际传的是引用的副本。
4.方法的返回值：（1）无返回值类型，用void。
（2）有返回值，必须用return，返回值类型为返回值的类型。
（3）如果在方法中直接写return，而没有返回值，则方法结束。
Eg01：package com.baidu;
public class NonReturn {
public static void main(String[] args) {
printQitao(3,5);
printQitao(6,7);
printQitao(3,9);
}
public static void printQitao(int height,int width){
for(int x=1;x<=height;x++){
for(int y=1;y<=width;y++){
System.out.print("*");
}
System.out.println( );
}
System.out.println();
}
}
Eg01中使用void是为无返回类型
Eg02：package com.baidu;
import java.util.Scanner;
public class HaveReturn {
public static void main(String[] args) {
Scanner scan=new Scanner(System.in);
System.out.print("请输入长方形的长：");
int height=scan.nextInt();
System.out.print("请输入长方形的宽：");
int width=scan.nextInt();
int area=getArea(height,width);
System.out.println("此长方形的面积为："+area);
}
public static int getArea(int x,int y){
int temp=x*y;
return temp;
}
}
Eg02是为无返回值类型
5.方法的调用：
·直接调用：方法名（参数）
·类名调用：类名.方法名（参数）
·对象调用：对象.方法名（参数）
6.递归算法【重点】（递推与回归）：方法实现自我调用，自己调用自己。条件：（1）递归出口，（2）逐层递归，向其出口接近。
Eg：package com.baidu;
import java.util.Scanner;
public class Recursion {
public static void main(String[] args) {
Scanner scan=new Scanner(System.in);
System.out.println("请输入要累加的个数：");
int num=scan.nextInt();
int sum=getSum(num);
System.out.println("1到"+num+"的和是："+sum);
}
public static int getSum(int x){
if(x==1){
return 1;
}else{
int temp=getSum(x-1);
return temp+x;
}
}
例中实现了方法的递归，用来计算一到num之间整数的累加。
方法部分小结：（以解决汉诺塔游戏的程序来综合总结）
Eg：package com.game;
import java.util.Scanner;
public class Hanoi {
public static int count=0;
public static void main(String[] args) {
Scanner scan=new Scanner(System.in);
System.out.println("请输入盘子数：");
int sum=scan.nextInt();
hanoi(sum,'A','B','C');
}
public static void hanoi(int panNumber,char start,char help,char dest){
if(panNumber==1){
count++;
System.out.println("这是第"+count+"次移动，将一个盘子从"+start+"棒移动到"+dest+"棒上");
}else{
hanoi(panNumber-1,start,dest,help);
count++;
System.out.println("这是第"+count+"次移动，将一个盘子从"+start+"棒移动到"+help+"棒上");
hanoi(panNumber-1,help,start,dest);
}
}
}
三.数组
·属于引用数据类型，用来相同类型的一组数据（声明一个数组就是在内存中划出一串连续的空间）。
·标识符:数组的名称，用来区分不同类型的数组。
·长度属性：length（固定不变，避免越界）。
·元素下标：对数组元素进行编号，从0开始，数组中所有元素都可以通过下标来访问。
声明数组：（1）int[] score1
int score2[] （3）String[] name
声明时不规定长度,int,String等是数据类型，score1，score2等是数组名称。
分配空间：（空间连续）
Eg：score=new int[30];
Avage=new int[6];
Name=new String[7];
数组格式:
数据类型[] 数组名=new 数据类型[大小]
Eg：int[] a=new int[大小]
Int[] a={元素...........}
数组遍厉：（1）通过for循环获取数组元素的下标，然后遍历对应元素
格式for(int i=0;i<array.length;i++){
// 逐个遍历元素array[i]
}
（2）foreach输出
for(数据类型 变量名称:数组名称){
…
}
对上述两种遍厉方法举例说明：
Eg：package org.bai;
public class ArrayDemo {
public static void main(String[] args) {
int[] a=new int[7];
a [0]=23;
a [1]=44;
a [2]=56;
a [3]=66;
a [4]=78;
System.out.println("遍历第一个数组：");
for(int i=0;i<a.length;i++){
System.out.print(a [i]+" ");
}
System.out.println();
int[] b={78,56,45,67,90,2,12,23};
System.out.println("遍历第二个数组：");
for(int i=0;i<b.length;i++){
System.out.print(b[i]+" ");
}
System.out.println();
System.out.println("新方法遍厉b数组：");
for(int x:b){
System.out.print(x+" ");
}
}
}
数组的内存图
（补充）方法的可变参数：方法中可传递的参数不再固定，而可以传递数量不等的参数。
定义格式：返回值类型 方法名称（类型... 参数名称）
Eg：package org.bai;
public class ChangNumber {
public static void main(String[] args) {
show(4,5);
show(6,9,8,2);
show(4,57,2);
}
public static void show(int...a){
System.out.println("当前数组有："+a.length+"个元素" );
for(int i=0;i<a.length ;i++){
System.out.print(a[i]+" ");
}
System.out.println();
}
}
数组的拷贝：利用system中的静态方法:
public static native void arrayCopy（object src,int srcPos,object dest ,int destPOS,int length）
·src:源数组
·srcPos:源数组起始位置
·dest：目标数组
·destPos:目标数组起始位置
·length：拷贝数组元素个数
排序【重点】
(1)冒泡排序： 共有n个数据，则需要进行n-1趟排序(可优化)，每一趟排序都会过“两两交换”的方式对数据进行比较，每一趟排序后都会将本趟排序的最大值“冒”到后面。
Eg:package org.bai;
public class bubbleSort {
public static void main(String[] args) {
int[] a={45,12,76,65,23,67,25,89,47};
bubbleSort(a);
}
public static void bubbleSort(int[] a){
for(int i=1;i<a.length;i++){
for(int j=0;j<a.length-i;j++){
if(a[j]>a[j+1]){
int temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
System.out.println("这是第"+i+"次排序，结果为：");
for(int x:a){
System.out.print(x+" ");
}
System.out.println();
}
}
}
（2）插入排序：对一个有n个元素的数据序列，排序需要进行n-1趟插入操作(可优化)。
第一趟插入将第2个元素插入前面的有序子序列(此时前面只有一个元 素)。
第二趟插入将第3个元素插入前面的有序子序列，前面两个元素是有序的。
第n-1趟插入将第n个元素插入前面的有序子序列，前面n-1个元素是 有序的
Eg：package org.bai;
public class InsertSort {
public static void main(String[] args) {
int[] a={45,12,76,65,23,67,25,89,47};
insertSort(a);
}
public static void insertSort(int[] a){
for(int i=1;i<a.length-1;i++){
int dete=a[i];
int j=i+1;
if(j>=0 && dete>a[j]){
}
}
}
}
（3）快速排序：从待排序的数据序列中任取一个数据(如第一个数据)作为分界值，所有比 它小的数据元素放到左边，所有比它大的数据元素放到它的右边。
接下来，对左右两个子序列按照上述方法进行递归排序，直到排序完成。
Eg：package sort;
public class QuickSort {
public static void main(String[] args) {
int[] a={22,55,11,66,88,77,44,99,33};
quickSort(a,0,a.length-1);
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+" ");
}
}
public static void quickSort(int[] array,int start,int end){
if(start>=end){
return;
}
int data=array[start];
int i=start+1;
int j=end;
while(true){
while(i<=end && array[i]<data){
i++;
}
while(j>=start+1 && array[j]>data){
j--;
}
if(j>i){
int temp=array[i];
array[i]=array[j];
array[j]=temp;
}else{
break;
}
}
array[start]=array[j];
array[j]=data;
quickSort(array,start,j-1);
quickSort(array,j+1,end);
}
}
四.二维数组
声明实例化：
格式：数据类型[] 数组名称=new 数据类型[行的个数][列的个数]
·length是他们包含行的个数
访问具体元素的语法：
格式：数组名称[行索引][列索引]
二维数组的遍厉：
Eg：package com.baidu;
public class ArrayDemo {
public static void main(String[] args) {
int[][] a=new int[3][4];
a[0] =new int[]{22,33,44,55};
a[1] =new int[]{23,35,45,26};
a[2] =new int[]{24,37,28,56};
for(int i=0;i<a.length;i++){
for(int j=0;j<a[i].length;j++){
System.out.print(a[i][j]+" ");
}
System.out.println();
}
}
}
（补充）二维数组的使用
Eg：package org.bai;
public class ArraySum {
public static void main(String[] args) {
int[][] a=new int[3][4];
a[0] =new int[]{22,33,44,55};
a[1] =new int[]{23,35,45,26};
a[2] =new int[]{24,37,28,56};
int sum=0;
for(int i=0;i<a.length;i++){
int groupsum=0;
for(int j=0;j<a.length;j++){
groupsum+=a[i][j];
System.out.println("小组内每"+(j+1)+"人的销售额： "+groupsum);
}
sum+=groupsum;
System.out.println("第"+(i+1)+"组的总销售额是："+sum);
System.out.println("***************");
}
System.out.println("本季度总销售额是："+sum);
}
}
本次总结小结：
·难点：（1）方法递归
（2）数组快速排序
【开源（11.25.Java）】
【2017.12.05】
原文地址：http://blog.51cto.com/13501268/2047689
