半个月总结

 

Javase总结

1、JAVASE 桌面应用开发版本

2、JAVA是一门高级的编译解释型的计算机编程语言。

3、JAVA的历史与创造者：

1990年12月java诞生，由詹姆斯*高斯林和一群做c++的程序工程师一起发明的。这时的名字叫oak；

1995年被orakle公司收购，正式更名为java；

4、开发JAVA程序的步骤

（1）编写一个JAVA源文件（*.java）

（2）在JAVA源文件中写个类：

Public class Asss{

}

（3）类里面书写方法

public class Asss{

public static void main（String[ ] args）{

}

}

（4）用编译器来编译java源文件（*.class，字节码文件）

（5）用解析器来解析字节码文件

（6）系统执行操作

5、java基本数据类型：

（1）整型（byte （字节整型8位，范围为-2^7到2^7-1）   short（短整型16位,范围为-2^15到2^15-1）    int（整型32位,范围为-2^31到2^31-1）    long（长整型64位,范围为-2^64到2^64-1））

注意：在没有定义数值类型的时候：默认为int类型；

例如：short a=1；（华为测试题）

  a=a+1；//这是错误的；因为没有定义1的类型所有默认为计算的结果为整型；

因此要从到大范围到小的范围要进行强制转换；小范围到大范围自动转换；

（2）浮点型(float（单精度浮点型，32位,范围为-2^32到2^32-1） double（双精度浮点型，64位,范围为-2^64到2^64-1）)

注意：没有定义浮点型的类型的时候，默认为double类型，要为float的类型，需要在数字后面加上一个f/F;

例如：

float a=1.0；

//这是错误的，对于初始化的时候 的数值默认为double类型的，所以要加上f，表示float类型

（3）字符型(char)

例如：

char s=’A’;

用单引号隔开；

String s=” AS”;

用双引号隔开； 

（4）布尔型(boolean)

例如：

Bloolean temp=true；

复合数据类型：

以后才学，现在略；

6、java的注释：

（1）单行注释 //

（2）多行注释 /*   */

（3）文本注释/**   */

7、标识符有（字母，下划线，数字，美元符号）

（1）不能与数字开头

（2）不能使关键字（当前我学过的关键字有：class，null，public ，void等等）

（3）区分大小写

8、变量的初始化

数据类型  标识符;int a;

变量的初始化

（1） int a=0;

（2） int a; 

  a=0;

9、运算符

（1）算术运算符

==，+，-，*，/，%

（2）关系运算符

>=,>,<=,<

（3）逻辑运算符

|| ,&&,|,&

（4）位运算符

（5）其他运算符

（6）三目运算符 ?:

例如：

语句的真假判断？为真的时候输出的值：为假的时候输出的值

10、流程控制

if()

(1)单分支:

if(判断条件){

输出语句；

}

(2)双分支：

if(判断条件){

输出语句；

}else{

输出语句；

}

(3)多分支：

if(判断条件){

输出语句；

}

else if(判断条件){

输出语句；

}

else{

输出语句；

}

(4)嵌套：

if(){

if(){

}

}

注意：使用if判断语句的时候，根据程序执行的顺序来判断的；if或者是else if括号里面的为布尔类型的值，或者是表达式；比如：temp为真的时候，里面的表达式的值都是为真的时候才进行输出；

For循环语句的使用：

(1) 格式为：

For（int a=0；a<=10;a++）{

}

(2)嵌套循环的格式为：

For（int a=0；a<=10;a++）{

For（int i=0；i<=10;i++）{

}

}

对于for循环的使用特点是：执行一次后一定会加加1；在执行下一次；对于嵌套循环的最里面的计数器的值是，外层循环结束后，都会重新从1开始；而且，这里的计数器只是记录的是数值而已；初始值为0,1都可以；只是根据情况进行选择；

While循环的格式：

Int a=1；

While（a<4）{

i++;

}

While循环也可以用嵌套的，但是循环的次数是不一定的，i++的次数是一定的；

Do循环：

格式为：

Do{

语句；

I++；

}while（i<5）

注意：这个循环至少执行一次；

Swith语句：

格式为：

Switch(为int，short，char，byte类型的表达式){

Case 值1：

输出语句；

Break；

Case 值2：

输出语句；

Break；

Case 值3：

输出语句；

Break；

}

11.数组

一维数组：

静态初始化：

Int[] a={1,2,3,4,5,6};

动态初始化：

Int[] a=new int[5];

二维数组：

静态初始化：

Int[][] a={{1,2,3,4,5,6},{1,2,3,4,5,6},{1,2,3,4,5,6}};

动态初始化：

Int[] []a=new int[5][5];

操作数组的时候，我们都是来操作的是数组的下标；操作下标，就可以操作数组里面的值；

对于数组的遍历，要用循环来遍历，根据下标来判断的；

12.方法的封装的格式：

无返回值的：
public static void 方法名字（参数列表）{

方法体；

}
有返回值的：
public static 类型 方法名字（参数列表）{

方法体；

}
注意，参数列表的意思是方法体里面有操作的数；三个不同：参数列表的类型不同，名字不同，个数不同；

方法的调用：

可以方法调用方法；

方法的递归调用：

求阶乘：

例如：

Public static int jc(int a){

If(a==1){

Return 1;//这里代表最后一个数就退回，

}

Return a*jc(a-1);//这里代表自己调用自己；

}

已经封装好了的方法的使用：

Public static void main(){

方法名字（变量值）；

}

14,对数组的排序：

分为选择排序法，和冒泡排序法，快速排序法：

以此的格式为：

调用包：

Import java.util.Arrays;

Arrays.sort(数组名);

For(int i=0;i<10;i++){

For(int j=i+1;j<10;j++){

If(a[i]>a[j]){

Int temp=a[i];

a[i]=a[j];

a[j]=temp;

}

}

}

之前做过的提，对题的总结：

水仙花数：

public class Asss{

public static void main(String []args){

int a=254;

int bw=a/100;

int sw=a/10%10;

int gw=a%10;

if(bw*bw*bw+sw*sw*sw+gw*gw*gw==a){

System.out.println(a+"是水仙花数");

}

else{

System.out.println(a+"不是水仙花数");

}

}

}

(学点1)         这里是使用数组的操作他的每一位的数字，然后进行比较；

对于整形的类型容易错的：

public class Asss{

public static void main(String []args){

short a=1;

a=a+1;//错误，改成  a=(short)(a+1);//直接运算的话没有定义1的类型，就是默认为结果为整形的,而且不会自动转化

System.out.println(a);

}

}

public class Asss{

public static void main(String []args){

//float a=1.1234;//错误，改成  

float a=1.1234f;//double a=1.1234f;没有f默认为float；

System.out.println(a);

}

}

这些，代表，取位数的运算；

public class Asss{

public static void main(String []args){

int a=24;

int sw=a/10;//这些，代表，取位数的运算；

int gw=a%10;

if(sw>gw){

int s=gw*10+sw;

System.out.println(s);

}

else{

int g=(sw+1)*10+gw;

System.out.println(g);

}

}

}

这代表，条件和逻辑或的运算

public class Asss{

public static void main(String []args){

int a=2;

if(a==1||a==3||a==5||a==7||a==8||a==10||a==12){

System.out.println(a+"为31天");

}

else if(a==4||a==6||a==9||a==11){

System.out.println(a+"为30天");

}

else{

System.out.println(a+"为28天 或者29天");

}

}

}

这代表逻辑与和条件范围的运算；

public class Asss{

  public static void main(String []args){

  int a=7;

if(a<=6&&a>=0){

System.out.println(a+"岁为幼儿");

}

else if(a>6&&a<=12){

System.out.println(a+"岁为儿童");

}

else if(a>12&&a<=16){

System.out.println(a+"岁为青少年");

}

else if(a>16&&a<=30){

System.out.println(a+"岁为成年人");

}

else{

System.out.println(a+"岁为中年人");

}

}

}

这的代表，嵌套

public class Asss{

public static void main(String []args){

int a=68;

if(a>=0&&a<=100){

int s=a/10;

switch(s){

case 10:

System.out.println("优秀");break;

case 9:

System.out.println("良好");break;

case 8:

System.out.println("中等");break;

case 7:

case 6:

System.out.println("差");break;

default:

System.out.println("不及格");break;

}

}

else{

System.out.println("无效分数");

}

}

}

这代表计数器的使用方法：

public class Test9{

public static void main(String []args){

int a=0;

switch(a){

case 0:

a++;

case 1:

a++;

case 2:

a++;

System.out.println(a);

}

}

}

if 的嵌套，使用

public class Asss{

public static void main(String []args){

int a=121;

if(a>=0&&a<=120){

if(a>=23&&a<=30){

System.out.println("适合结婚年龄");}

else{

System.out.println("未婚或者已婚");

}

}

else{

System.out.println("无效年龄");

}

}

}

public class Demo{

public static void main(String []args){

int i;

for(i=0;i<=100;i++){

if(i/2!=0)System.out.println("素数："+i);

}

}

}

用来计算：：：：   每个位的位数的；

public class Asss{

public static void main(String []args){

int i;

for(i=0;i<=1000;i++){

int qw=i/1000;

int bw=i/100%10;

int sw=i/10%10;

int ge=i%10;

if(ge==sw||(ge==sw&&sw==bw)||(ge==sw&&sw==bw&&bw==qw))System.out.println(i);

}

}

}

对这一道题进行，全面的总结：

public class Asss{

//定义一个方法判断点数//参数列表里面代表的是变量类型和变量的名字，这里是不能进行初始化的，只有在调用方法的时候，在主方法里面的（）内输入变量的值

public static String  getNum(String str){

String s="";

if(str.equals("A")){//.equals()代表的是对于字符串类型的比较的；目前只学了相等的；

s="1";

}else if(str.equals("J")){

s="10";

}else if(str.equals("Q")){

s="10";

}else if(str.equals("K")){

s="10";

}else{

s=str;

}

return s;//变量的名字，返回的类型；

}

//定义一个方法判断重复

public static boolean  isRepeat(String c,String[][] cards){

//返回true为不重复，返回false重复

boolean temp=true;

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

if(cards[i][0]!=null){

if(cards[i][0].equals(c)){

temp=false;

break;

}

}

}

return temp;//真和 假的判断，使用的办法而已：

}

public static void main(String[] args){

String[] colors={"红桃","黑桃","方块","梅花"};

String[] nums={"A","2","3","4","5","6","7","8","9","10","J","Q","K"};

String[][] cards=new String[52][3];//{{"黑桃K","13"},{"黑桃A","1"},{"梅花5","5"}}

int i=0;

while(i<cards.length){

String[] card=new String[3];//定义二维数组里面的数；

int a=(int)(Math.random()*nums.length);//这里表示随机数的（0--1）*数字，表示的范围；

int b=(int)(Math.random()*colors.length);

String c=colors[b]+nums[a];//字符串也可以直接相加

if(isRepeat(c,cards)){//c代表随机一次的牌，cards代表总的牌，只是初始化为0；；

card[0]=c;

String num=getNum(nums[a]);

card[1]=num;

card[2]=colors[b];

cards[i]=card;

}else{

continue;

}

i++;

}

//随机产生一张牌

int j=0;

String[][] sjp=new String[6][3];//定义的两张牌；

while(j<6){

int m=(int)(Math.random()*cards.length);

String c=cards[m][0];//前面的为二维数组，所有这里赋值也要定义为二维数组；//只是赋值第一层里面的第二层的第一个数

if(isRepeat(c,sjp)){

sjp[j]=cards[m];//表示的是第一层；

}

else{

continue;

}

j++;

}

//System.out.print(sjp[0][0]+sjp[1][0]+sjp[2][0]+sjp[3][0]+sjp[4][0]+sjp[5][0]);

int wj1=Integer.parseInt(sjp[0][1])+Integer.parseInt(sjp[1][1])+Integer.parseInt(sjp[2][1]);

int wj2=Integer.parseInt(sjp[3][1])+Integer.parseInt(sjp[4][1])+Integer.parseInt(sjp[5][1]);

String zf1=sjp[0][0]+sjp[1][0]+sjp[2][0];

String zf2=sjp[3][0]+sjp[4][0]+sjp[5][0];

if(wj1<21&&wj2<21&&wj2>wj1){

System.out.print("玩家2：  "+zf2+"      赢家                 "+"玩家1：  "+zf1);

}

if(wj1<21&&wj2<21&&wj1>wj2){

System.out.print("玩家1：  "+zf1+"      赢家                  "+"玩家2：  "+zf2);

}

if(wj1>21&&wj2<=21){

System.out.print("玩家1：  "+zf1+"      爆炸                            "+"玩家2：  "+zf2+"  赢家");

}

if(wj1<=21&&wj2>21){

System.out.print("玩家2：  "+zf2+"      爆炸                            "+"玩家1：  "+zf1+"  赢家");

}

if(wj1>21&&wj2>21){

System.out.print("玩家2：  "+zf2+"      爆炸                            "+"玩家1：  "+zf1+"  爆炸");

}

}

}