java基础

来源：互联网发布：开源oa系统源码下载编辑：程序博客网时间：2024/05/23 17:44

java语言基础
package code;

public class test {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("<--这是我第一次使用Eclipse!-->");

}

}
<--这是我第一次使用Eclipse!-->

java语言的数据类型：（1）整数类型：byte(8位,范围-2^7-2^7-1)/short/int/long;

(2)浮点类型：float(32位,范围：1.4E-45到3.4028235E38）/double;

(3)字符类型:char;

(4)布尔类型：boolean;
类型转换

1自动转换：（1）进行转换的两种类型是兼容的。
（2）目标类型的范围大于源类型的范围。
2强制转换：

public class ForceTyeConversion {
public ForceTyeConversion() {
super();
System.out.println("<--在这里定义ForceTypeConversion的构造方法-->");
}
public static void main(String[] args) {
byte b;
short s;
char c;
int i;
double d;
d=13.13d;
i=(int)d;
System.out.println("<--d="+d+"-->");
System.out.println("<--i="+i+"-->");
i=65636;
c=(char) i;
System.out.println("<--i="+i+"-->");
System.out.println("<--c="+c+"-->");
s=28;
b=(byte) s;
System.out.println("<--s="+s+"-->");
System.out.println("<--b="+b+"-->");
}
}
<--d=13.13-->
<--i=13-->
<--i=65636-->
<--c=d-->
<--s=128-->
<--b=-128-->

package code;

public class TypePrmotion {
public TypePrmotion() {
super();
System.out.println("<--在这里定义TypePromotion的方法-->");
}

/**
* @param args
*/
public static void main(String[] args) {
  // TODO Auto-generated method stub
  byte b=10;
  byte result=(byte)(b+4);
  System.out.println("<--result为"+result+"-->");

}
}
<--result为14-->

上面的强制类型转换时必须的，因为在java中会进行类型提升，这种表达式中的类型提升是自动的。

提升的规则是将表达式的运算结果的类型提升为所有操作数数据类型中范围最大的数据类型。

变量：程序的一个基本存储单元。变量由变量名、数据类型和可选的初始值定义。
变量名必须满足以下条件：
（1）变量名必须是一个合法的标识符；（在java语言中，标识符是以字母、下划线（_)和美元符（$）开始的一个字符序列，后面
可以跟字母、下划线、美元符和数字。）

（2）变量名必须不是一个保留字；（java中的保留符又称关键字。java中的保留字全部用小写字母表示，他们也不能当做合法的标
识使用。java中保留字有：abstract/break/byte/boolean/catch/case/class/char/cntinue/default/double/do/else/extends/false/final/float/for/finally/if/import/implements/int/interface/instaneof/long/length/native/new/null/package/private/protected/public/return/switch/synchronized/short/static/super/try/true/this/throw/throws/threadsafe/transient/void和while.)

（3）变量名必须在作用域中唯一；

变量声明：数据类型变量名 [=初始值] [,变量名[=初始值]……];

package example.code.basic;
public class VariableDeclare {
public stdtic void main(String[] args) {
   int i,j,k;
   char c='c';
   long l,m=1L,n;
}
}

作用域可以嵌套，外部的作用域的变量对于内部作用域是可见的，但内部作用域的变量对外部是不可见的）

数组

一维数组就是具有相同数据类型的有序变量集合。

声明方法：数据类型数组名[] 或者数据类型[] 数组名；

分配空间：数组名=new 数据类型[数组大小] 或者数据类型[] 数组名=new 数据类型[数组大小];

package exmaple.code.basic;
public class ArrayDemo {
public static void main(String[] args) {
char[] firstArray;
char secondArray[]=new char[10];
firstArray=new char[26];
firstArray[0]='a';
firstArray[1]='b';
firstArray[2]='c';
firstArray[3]='d';
firstArray[4]='e';
firstArray[5]='f';
firstArray[6]='g';
firstArray[7]='h';
firstArray[8]='i';
firstArray[9]='j';
firstArray[10]='k';
firstArray[11]='l';
firstArray[12]='m';
firstArray[13]='n';
firstArray[14]='o';
firstArray[15]='p';
firstArray[16]='q';
firstArray[17]='r';
firstArray[18]='s';
firstArray[19]='t';
firstArray[20]='u';
firstArray[21]='v';
firstArray[22]='w';
firstArray[23]='x';
firstArray[24]='y';
firstArray[25]='z';
}
}

数组也可以在声明时被初始化，方法为：

数据类型[] 数组名={初始值，初始值，……初始值}；
数据类型数组名[]={初始值，初始值，……初始值}；

package example.code.basic:
public class ArrayInit{
public static voud main(String[] args) {
   char[] lowerCaseWord={'a','b','c','d','e','f','g','h','l','m','n','o','p','q',
                      'r','s','t','u','v','w','x','y','z'};
   char upperCaseWords[]={'A','B','C','D','E','F','G'……,'Z'};
   System.out.println("<--26个小写字母:");
   System.out.println(lowerCaseWords);
   System.out.println("-->");
   System.out.println("<--26个大写字母:");
   System.out.println("upperCaseWords);
   System.out.println("-->");
}
}

二维数组声明方法：数据类型数组名[][] 或者数据类型[][] 数组名；

分配内存方法为：数组名=new 数据类型[行数组大小][列数组大小];

另一种二维数组声明方法:

数组名=new 数据类型[行数组大小][];

数组名[0]=new 数据类型[数组大小]；

数组名[1]=new 数据类型[数组大小];

……………………………………………
……………………………………………

package exmaple.code.basic;
public class MutiArrayDemo {
public static void main(String[] args) {
int[][] firstArray;
int secondArray[][]=new int[2][2];
firsrArray=new int[3][];
firstArray[0]=new int[1];
firstArray[1]=new int[2];
firstArray[2]=new int[3];
firstArray[0][0]=1;
firstArray[1][0]=2;
firstArray[1][1]=3;
firstArray[2][0]=4;
firstArray[2][1]=5;
firstArray[2][2]=6;
secondArray[0][0]=1;
secondArray[0][1]=2;
secondArray[1][0]=3;
secondArray[1][1]=4;
}
}

package example.code.basic;
public class MutiArrayInit {
public static void main(String[] args) {
char[][] firstArray={{'1','2'},{'3','4'}};
char secondArray[][]={{'1'},{'2','3'},{'4','5','6'}};
System.out.println("<--第一个二维数组开始-->");
System.out.println(firstArray[0]);
System.out.println(firstArray[1]);
System.out.println("<--第一个二维数组结束-->");
System.out.println("<--第二个二维数组开始-->");
System.out.println(secondArray[0]);
System.out.println(secondArray[1]);
System.out.println(secondArray[2]);
System.out.println("<--第二个二维数组结束-->");
}
}

var2=var1++;
等加于
var2=var1;
var1=var1+1;
而
var2=++var1;
等价于
var1=var1+1;
var2=var1;

var?var1:var2;
如果var的值为True，那么表达式的结果为var1的值；否则为var2的值。

位运算符的优先级（1代表最高，2代表最低）

优先级   运算符
1        [] ()
2        ++ -- ! ~
3        * / %
4        + -
5        >> >>> <<
6        > < >= <=
7        == !=
8        &
9        ^
10       |
11       &&
12       ||
13       ?:
14       = += -=/ *= /= %= ^=
15       &= |= <<= >>= >>>=

package example.code.basic;

public class IfElseDemo {
private static void judge(int result) {
  System.out.println("<--成绩为"+result+"-->");
  if(result>=60) {
   System.out.println("<--恭喜，这个成绩合格！-->");
  }else{
   System.out.println("<--很遗憾，这个成绩不合格！");
  }
}
public static void main(String[] args){
int firstResult=80;
int secondResult=45;
judge(firstResult);
judge(secondResult);
}
}
<--成绩为80-->
<--恭喜，这个成绩合格！-->
<--成绩为45-->
<--很遗憾，这个成绩不合格！

package example.code.basic;

public class NestIfElseDemo {
private static void judge(int result){
  System.out.println("<--成绩为"+result+"-->");
  if(result<0||result>100){
   System.out.println("<--对于百分制这个成绩不合法，请检查输入的成绩！-->");
  }else{
   if(result>=60){
    System.out.println("<--恭喜，这个成绩合格！");
   }else{
    System.out.println("<--很遗憾，这个成绩不合格!-->");
   }
   }
  }

public static void main(String[] args){
int firstResult=80;
int secondResult=45;
int thirdResult=-10;
judge(firstResult);
judge(secondResult);
judge(thirdResult);
}
}
<--成绩为80-->
<--恭喜，这个成绩合格！
<--成绩为45-->
<--很遗憾，这个成绩不合格!-->
<--成绩为-10-->
<--对于百分制这个成绩不合法，请检查输入的成绩！-->

package example.code.basic;

public class SwitchDemo {
public static String getMonthInEn(int month) {
  String monthEn=null;
  switch(month){
  case 1:
   monthEn="January";
   break;
  case 2:
   monthEn="February";
   break;
  case 3:
   monthEn="March";
   break;
  case 4:
   monthEn="April";
  case 5:
   monthEn="May";
   break;
  case 6:
   monthEn="June";
   break;
  case 7:
   monthEn="july";
   break;
  case 8:
   monthEn="August";
   break;
  case 9:
   monthEn="September";
   break;
  case 10:
   monthEn="October";
   break;
  case 11:
   monthEn="November";
   break;
  case 12:
   monthEn="December";
   break;
   default:
    monthEn="";
  }
  return monthEn;
}
  public static void main(String[] args){
   int month;
   String monthEn;
   month=1;
   monthEn=getMonthInEn(month);
   System.out.println("<--"+month+"月的英文单词为"+monthEn+"-->");
   month=11;
   monthEn=getMonthInEn(month);
   System.out.println("<--"+month+"月的英文单词为"+monthEn+"-->");
   }

}
<--1月的英文单词为January-->
<--11月的英文单词为November-->

package example.code.basic;
public class whileDemo{
public static void main(String[] args){
System.out.println("<--启动倒计时开始……-->");
int i=10;
while (i>0){
System.out.println("<--"+i+"-->");
i--;
}
System.out.println("<--启动！！！-->");
}
}

do-while语句现执行循环语句内的程序代码，然后判断是否满足条件。
package example.code.basic;
public class DoWile{
public static void main(String[] args){
System.out.println("<--启动倒计时开始……-->");
int i=10;
do{
System.out.println("<--"+i+"!-->");
i--；
}while（i>0）；
System.out.println("<--启动！！！");
}
}

continue语句只是跳出本次循环，在continue后面的循环体中的程序代码将不被执行，然后直接进行循环条件判断。
package exmaple.code.basic;
public class ContinuteDemo {
public static void main(String[] args){
   for(int i=1;i<11;i++){
         if(i%2==0）{
            continue；
          }
          System.out.println("<--第"+i+"次循环-->");
      }
}
}

package example.code.basic;

public class SortAlgorithm {

/**
* 冒泡算法
*
* @param data
*/
public static void bubble(int[] data){
  System.out.println("<--冒泡算法排序前的数据-->");
  printData(data);
  int outer,inner;
  for(outer=data.length-1;outer>1;outer--){
   for(inner=0;inner<outer;inner++){
    if(data[inner]>data[inner+1]){
     int temp=data[inner];
     data[inner]=data[inner+1];
     data[inner+1]=temp;
   }
  }
  }
System.out.println("<--冒泡算法排序后的数据-->");
printData(data);
}
public static void insert(int [] data){
System.out.println("<--插入算法排序前的数据-->");
printData(data);
int inner,outer;
for(outer=1;outer<data.length;outer++){
  int temp=data[outer];
  inner=outer;
  while (inner>0&&data[inner-1]>=temp){
   data[inner]=data[inner-1];
   --inner;
  }
  data[inner]=temp;
}
System.out.println("<--插入算法排序后的数据-->");
printData(data);
}

public static void select(int[] data){
System.out.println("<--选择算法排序前的数据-->");
printData(data);
int outer,inner,mid;
for(outer=0;outer<data.length-1;outer++){
  mid=outer;
  for(inner=outer+1;inner<data.length;inner++){
   if(data[inner]<data[mid]){
      mid=inner;
  }
  int temp=data[outer];
  data[outer]=data[mid];
  data[mid]=temp;
}
}
    System.out.println("<--选择算法排序后的数据-->");
    printData(data);
}

public static void printData(int[] data) {
  for(int i=0;i<data.length;i++){
   System.out.println("<--第"+i+"个是："+data[i]+"-->");
  }
}

public static void main(String[] args) {
int[] data={13,24,59,78,30,14,32,6,5,81,48};
SortAlgorithm.bubble(data);
SortAlgorithm.insert(data);
SortAlgorithm.select(data);
}
}
<--冒泡算法排序前的数据-->
<--第0个是：13-->
<--第1个是：24-->
<--第2个是：59-->
<--第3个是：78-->
<--第4个是：30-->
<--第5个是：14-->
<--第6个是：32-->
<--第7个是：6-->
<--第8个是：5-->
<--第9个是：81-->
<--第10个是：48-->
<--冒泡算法排序后的数据-->
<--第0个是：5-->
<--第1个是：6-->
<--第2个是：13-->
<--第3个是：14-->
<--第4个是：24-->
<--第5个是：30-->
<--第6个是：32-->
<--第7个是：48-->
<--第8个是：59-->
<--第9个是：78-->
<--第10个是：81-->
<--插入算法排序前的数据-->
<--第0个是：5-->
<--第1个是：6-->
<--第2个是：13-->
<--第3个是：14-->
<--第4个是：24-->
<--第5个是：30-->
<--第6个是：32-->
<--第7个是：48-->
<--第8个是：59-->
<--第9个是：78-->
<--第10个是：81-->
<--插入算法排序后的数据-->
<--第0个是：5-->
<--第1个是：6-->
<--第2个是：13-->
<--第3个是：14-->
<--第4个是：24-->
<--第5个是：30-->
<--第6个是：32-->
<--第7个是：48-->
<--第8个是：59-->
<--第9个是：78-->
<--第10个是：81-->
<--选择算法排序前的数据-->
<--第0个是：5-->
<--第1个是：6-->
<--第2个是：13-->
<--第3个是：14-->
<--第4个是：24-->
<--第5个是：30-->
<--第6个是：32-->
<--第7个是：48-->
<--第8个是：59-->
<--第9个是：78-->
<--第10个是：81-->
<--选择算法排序后的数据-->
<--第0个是：5-->
<--第1个是：6-->
<--第2个是：13-->
<--第3个是：14-->
<--第4个是：24-->
<--第5个是：30-->
<--第6个是：32-->
<--第7个是：48-->
<--第8个是：59-->
<--第9个是：78-->
<--第10个是：81-->