java基础学习03（java基础程序设计）

java基础程序设计

一、完成的目标

1. 掌握java中的数据类型划分
2. 8种基本数据类型的使用及数据类型转换
3. 位运算、运算符、表达式
4. 判断、循环语句的使用
5. break和continue的区别

二、数据类型划分

java的数据类型可分为基本数据类型与引用数据类型。基本数据类型包括了最基本的boolean、char、byte、short、int、long、float、double;引用数据类型是以一种特殊的方式指向变量的实体，这种机制类似于C/C++.

三、基本数据类型

java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间。

byte   1个字节
short  2个字节
int    4个字节
long   8个字节
float  4个字节
double 8个字节
char   2个字节

范围：

默认值：

数据溢出

public class DataDemo01{
    public static void main(String [] args){        
            int max = Integer.MAX_VALUE;                    //得到整数的最大值
            System.out.println("整数的最大值："+max);          //输出最大值
            System.out.println("整数的最大值+1："+(max+1));    //输出最大值+1
            System.out.println("整数的最大值+2："+(max+2));    //输出最大值+2
    }
 }

Process started >>>
整数的最大值：2147483647
整数的最大值+1：-2147483648
整数的最大值+2：-2147483647
<<< Process finished. (Exit code 0)

整数类型

当数据不带有分数或者小数时，可以声明整型变量。如35，-140。 在java中，整数类型可分为byte、short、int、long。对于一个整型常量，其类型默认就是int型。

字符类型（char）

字符类型在内存中占有两个字节，可以用来保存英文字母等字符。 字符要用一对单引号(‘‘)括起

/**
*1.声明字符类型的变量ch1,ch2
*2.将变量ch1的值设为字符b,ch2的值设为98
*3.输出字符变量ch1、ch2的内容
*/
class TestDemo01{
    public static void main(String [] args){
        char ch1 = ‘b‘;                     //定义字符
        char ch2 = 98;                      //定义字符，整型转字符
        System.out.println("ch1 = "+ch1);   //输出
        System.out.println("ch2 = "+ch2);
    }
}

Process started >>>
ch1 = b
ch2 = b
<<< Process finished. (Exit code 0)

转义字符

/**
*1.声明字符类型的变量ch1,ch2
*2.将变量ch1的值设为\",ch2的值设为\*3.输出字符变量ch1、ch2的内容,在打印的字符串中直接加入转义字符
*/

class TestDemo02{
    public static void main(String [] args){
        char ch1 = ‘\"‘;                        //定义转义字符双引号
        char ch2 = ‘\\‘;                        //定义转义字符反斜线
        System.out.println("ch1 = "+ch1);       //输出
        System.out.println("ch2 = "+ch2);
        System.out.println("\"Hello World\"");  //直接输出转义字符
    }
}

Process started >>>
ch1 = "
ch2 = "Hello World"
<<< Process finished. (Exit code 0)

浮点数类型(float,double) 
在java中，带有小数点的数值称为浮点数类型。使用浮点型数值时，默认类型是double。

/**
*1.声明浮点型的变量 num1,num2
*2.将变量 num1 的值设为4.0,num2的值设为3.0f
*3.输出num1*num1、num2*num2的值
*/

class TestDemo01{
    public static void main(String [] args){
        float num1 = 4.0;                               //定义float型变量
        float num2 = 3.0f;                              //定义float型变量
        System.out.println("两个小数相乘 "+num1*num1);    //计算两数相乘
        System.out.println("两个小数相乘 "+num2*num2);    //计算两数相乘
    }
}

Process started >>>
E:\TestDemo01.java:34: 错误: 不兼容的类型: 从double转换到float可能会有损失
        float num1 = 4.0;                       //定义浮点数
         ^
1 个错误
<<< Process finished. (Exit code 1)

将float num1 = 4.0;改为float num1 = 4.0f;

Process started >>>
两个小数相乘 16.0
两个小数相乘 9.0
<<< Process finished. (Exit code 0)

布尔类型(boolean) 
布尔（boolean）类型的变量，只有true（真）和false（假）两种。

/**
*1.声明boolean变量，并赋值true
*2.通常用来控制程序的流程
*/

class TestDemo01{
    public static void main(String [] args){
        boolean flag = true;                //定义boolean变量
        System.out.println("flag="+flag);   //输出
    }
}

四、数据类型的转换

数据类型自动转换
byte--->short--->int--->long--->float--->double
--------char---> int

/**
*1.数据类型转换
*/
public class DataDemo02{
    public static void main(String [] args){        
            int x = 30;                                 //定义整型变量
            float y = 22.19f;                           //定义浮点型变量
            System.out.println("x/y= " + (x/y) );       //整型变量除以浮点型变量-float类型
            System.out.println("10/0.35= "+(10/0.35));  //整型常量除以浮点型常量-浮点数据
            System.out.println("10/3= "+(10/3));        //整型常量除以整型常量-整型，小数部分被忽略
    }
}

Process started >>>
x/y= 1.3519603
10/0.35= 28.571428571428573
10/3= 3
<<< Process finished. (Exit code 0)

任何类型的数据都向String转型

/**
*1.定义字符串变量
*2.任何数据类型碰到String类型的变量或者常量之后都向String类型转换
*/
public class DataDemo03{
    public static void main(String [] args){        
            String  str = "billy";                      //定义字符串变量
            int x = 10;                                 //定义整型变量
            str = str + x;                              //改变字符串的内容
            System.out.println("str = "+ str );         //输出

            int i = 1;
            int j = 2;
            System.out.println("i + j = "+ i + j );     //输出 + 表示字符串连接
    }
}

Process started >>>
str = billy10
i + j = 12
<<< Process finished. (Exit code 0)

数据类型强制转换（显示转换） 
显示转换可能导致数据丢失，语法：（要转换的数据类型） 变量名称

/**
*1.数据类型强制转换
*/
public class DataDemo04{
    public static void main(String [] args){        
            float  f = 3.15f;                                //定义浮点型变量
            int x = (int)f;                              //强制转换int型变量
            System.out.println("x = "+ x );              //输出
            System.out.println("10/3 = "+ ((float)10/3 ) ); //常量计算使用强制类型转换
    }
}

Process started >>>
x = 3
10/3 = 3.3333333
<<< Process finished. (Exit code 0)

五、运算符、表达式与语句

运算符
赋值运算符 （=）
一元运算符（+ - ！）
算术运算符（+ - * / %（取模 即：取余数））
关系运算符（> < >= <= == !=）
自增 自减 运算符 （++，-- ）
逻辑运算符（&&，||，&，|）

对于&（与）来说，要求所有的条件都判断，而如果使用&&(短路与)如果第一个条件为false，则后面的条件将不再判断。
对于|（或）来说，要求所有的条件都判断，而如果使用||（短路或）如果第一个条件为true，则后面的条件将不再判断。

括号运算符（()）
位运算符（&，|，^(异或)，~，<<（左移），>>（右移），>>>（无符号右移））
运算符优先级

简洁表达式

 
范例：

六、选择与循环语句

一般来说程序的结构包括以下三种：顺序结构、选择结构、循环结构。这三种不同的结构有一个共同点，都只有一个入口，也只有一个出口。
顺序结构 
程序至上而下逐行执行，一条语句执行完之后继续执行下一条语句，一直到程序的末尾。 
 
选择结构 
根据条件的成立与否决定要执行哪些语句的一种结构。选择结构包括if、if...else、switch。

if语句

if(判断条件){
语句1；
语句2；
}

/**
*1.验证选择结构
*/
public class TestDemo05{
    public static void main(String [] args){        
            int x = 3;                               //定义整型变量x
            int y = 5;                               //定义整型变量y
            System.out.println("**开始比较两个数的大小**");       
            if(x > y){                               //判断x是否比y大
                System.out.println("x比y大！");
            }
            if(x<y){                                 //判断x是否比y小
                System.out.println("x比y小！");
            }
            System.out.println("**比较完成**");
    }
}

Process started >>>
**开始比较两个数的大小**
x比y小！
**比较完成**
<<< Process finished. (Exit code 0)  

if...else语句

if(判断条件){
语句主体1； 
}else{
语句主体2； 
}

/**
*1.判断一个数的是奇数还是偶数
*2.判断余数是否为1
*/

class TestDemo05{
    public static void main(String [] args){        
            int x = 4;                               //定义整型变量x  
            if(x % 2 == 1){                          //判断余数是否为1
                System.out.println("x是奇数！");
            }else{
                System.out.println("x是偶数！");
            }
    }
}

Process started >>>
x是偶数！
<<< Process finished. (Exit code 0)  

三目运算符（？ ： ）

变量 = 条件判断？表达式1：表达式2 
根据条件的成立与否，来决定结果为“：”前或“：”后的表达式，如果条件判断为true，则执行表达式1，为false则执行表达式2

/**
*1.使用三目运算符求出两个数字的最大值
*/

class TestDemo05{
    public static void main(String [] args){
            int max = 0;                             //定义变量保存最大值
            int x = 4;                               //定义整型变量x
            int y = 10;                              //定义整型变量y
            max = (x>y)?x:y;
            System.out.println("最大值为："+max);    //输出max

    }
}

Process started >>>
最大值为：10
<<< Process finished. (Exit code 0)  

if...else if...else语句

如果需要在if..else里判断多个条件时，就需要if..else if … else语句了，其格式如下：

if(判断条件1){
语句主体1； 
}else if(判断条件2){
语句主体2； 
} 
...//多个else if()语句
else{ 语句主体3； }

class TestDemo05{
    public static void main(String [] args){
            int x = 4;                               //定义整型变量x
            if(x==2){                                //判断x的值是否为2
                System.out.println("x的值是2");
            }else if(x==3){                         //判断x的值是否为3
                System.out.println("x的值是3");        
            }else if(x==4){                         //判断x的值是否为4
                System.out.println("x的值是4");
            }

    }
}

Process started >>>
x的值是4
<<< Process finished. (Exit code 0)

Switch结构

要在许多的选择条件中找到并执行其中一个符合判断条件的语句时，除了可以使用if..else不断地判断之外，也可以使用另一种更方便的方式即多重选择——switch语句，语法格式：

switch (表达式){
case 选择值1 ： 语句主体 1 ； break ；
case 选择值2 ： 语句主体 2 ； break ；
…….
case 选择值n ： 语句主体 n ； break ； 
default： 语句主体 ；
} 
要特别注意的是，在Switch语句中选择值只能是字符或常量。

/**
*1.判断学生成绩，并给出等级A(90~100)，B(>80)，C(>70)，D(>60)，E(0~59)
*/

class TestDemo05{
    public static void main(String [] args){
            int Score = 85;                              //定义一个学生的分数
            switch (Score/10){
                case 10:
                case  9: System.out.println("A级"); break;
                case  8: System.out.println("B级"); break;
                case  7: System.out.println("C级"); break;   
                case  6: System.out.println("D级"); break;
                default: System.out.println("E级"); break;
                }
    }
}

Process started >>>
B级
<<< Process finished. (Exit code 0)

/*
*每一个case语句后面都加上了一个break语句，如果不加入此语句的话，则
*switch语句会从第一个满足条件的case开始依次执行操作。
*/  

不加break，则
Process started >>>
B级
C级
D级
E级
<<< Process finished. (Exit code 0）  

循环结构 
循环结构则是根据判断条件的成立与否，决定程序段落的执行次数，而这个程序段落就称为循环主体。

while循环

while (循环条件判断){
语句1 ;
语句2 ;
…
语句n ;
循环条件更改 ;
}

/**
*1.使用while循环进行累加操作
*
*/

class TestDemo05{
    public static void main(String [] args){
            int i = 1;                               //定义整型变量i
            int sum = 0;                             //定义整型变量，保存累加结果
            while(i <= 100){                         //判断循环条件
                sum = sum + i;          //sum + = i; //执行累加结果
                i++;                                 //修改循环条件
            }
            System.out.println("1~100累加和--->"+sum);//输出
    }
}

Process started >>>
1~100累加和--->5050
<<< Process finished. (Exit code 0)  

do-while循环

do{
语句1 ;
语句2 ;
….
语句n ;
循环条件改变 ;
}
while (循环条件判断); 

/**
*1.使用do...while循环进行累加操作
*
*/

class TestDemo05{
    public static void main(String [] args){
            int i = 1;                               //定义整型变量i
            int sum = 0;                             //定义整型变量，保存累加结果
            do{                      //判断循环条件
                sum = sum + i;          //sum + = i; //执行累加结果
                i++;                                 //修改循环条件
            }
            while(i <= 100);
            System.out.println("1~100累加和--->"+sum);//输出
    }
}

Process started >>>
1~100累加和--->5050
<<< Process finished. (Exit code 0)   

for循环

对于while和do…while两种循环来讲，操作时并不一定非要明确的知道循环的次数，而如果开发者已经明确的知道了循环次数的话，那么就可以使用另外一种循环语句——for循环。

for (赋值初值；判断条件；赋值增减量){
语句1 ；
….
语句n ；
}

/**
*1.使用for循环进行累加操作
*
*/

class TestDemo05{
    public static void main(String [] args){
            int sum = 0;                             //定义整型变量，保存累加结果            
            for(int i=1;i<=100;i++){            
                sum = sum + i;          //sum + = i; //执行累加结果
            }
            System.out.println("1~100累加和--->"+sum);//输出
    }
}

Process started >>>
1~100累加和--->5050
<<< Process finished. (Exit code 0)



/**
*1.使用多重for循环打印九九乘法表
*
*/

class TestDemo05{
    public static void main(String [] args){
            for(int i=1;i<=9;i++){                  //第一层循环 
                for(int j=1;j<=i;j++){              //第二层循环
                    System.out.print(i+"*"+j+"="+(i*j)+"\t");//输出
                }
                System.out.println();//换行
            }

    }
}

Process started >>>
1*1=1   
2*1=2   2*2=4   
3*1=3   3*2=6   3*3=9   
4*1=4   4*2=8   4*3=12  4*4=16  
5*1=5   5*2=10  5*3=15  5*4=20  5*5=25  
6*1=6   6*2=12  6*3=18  6*4=24  6*5=30  6*6=36  
7*1=7   7*2=14  7*3=21  7*4=28  7*5=35  7*6=42  7*7=49  
8*1=8   8*2=16  8*3=24  8*4=32  8*5=40  8*6=48  8*7=56  8*8=64  
9*1=9   9*2=18  9*3=27  9*4=36  9*5=45  9*6=54  9*7=63  9*8=72  9*9=81  
<<< Process finished. (Exit code 0)

循环中断 
break语句 
break语句可以强迫程序中断循环，当程序执行到break语句时，即会离开循环，继续执行循环外的下一个语句，如果break语句出现在嵌套循环中的内层循环，则break 语句只会跳出当前层的循环。

/**
*1.使用break
*
*/

class TestDemo05{
    public static void main(String [] args){
            for(int i=1;i<=9;i++){                      
                if(i==3){                   //如果i=3,则退出整个循环
                    break;                  //退出整个循环
                }
                System.out.println("i = " + i);//
            }
            System.out.println("循环结束");
    }
}

Process started >>>
i = 1
i = 2
循环结束
<<< Process finished. (Exit code 0)  

continue语句
continue语句可以强迫程序跳到循环的起始处，当程序运行到continue语句时，即会停止运行剩余的循环主体，而是回到循环的开始处继续运行。

/**
*1.使用continue
*
*/

class TestDemo05{
    public static void main(String [] args){
            for(int i=1;i<=9;i++){                      
                if(i==3){                   //如果i=3,则退出整个循环
                    continue;                   //退出一次循环
                }
                System.out.println("i = " + i);//
            }
        System.out.println("循环结束"); 
    }
}

Process started >>>
i = 1
i = 2
i = 4
i = 5
i = 6
i = 7
i = 8
i = 9
循环结束
<<< Process finished. (Exit code 0)

注意： 

return语句

结束当前方法的执行并退出，返回调用该方法的语句处。

/**
*1.使用return
*
*/

class TestDemo05{
    public static void main(String [] args){
            for(int i=1;i<=9;i++){                      
                if(i==3){                   //如果i=3,则退出整个循环
                    return;                 //退出整个方法
                }
                System.out.println("i = " + i);//
            }
        System.out.println("循环结束");

    }
}

Process started >>>
i = 1
i = 2
<<< Process finished. (Exit code 0)
可以看到“循环结束”没有输出，当i=3时，满足执行return，结束整个方法的执行。

七、要点

1. 基本数据类型及其转换
2. 选择与循环语句