Java基础-CFANZ编程社区

java基础

Java基本格式

修饰符 class 类名{

程序代码

}

编译

是指将已经完成的Java源程序编译为计算机可识别运行的class文件 javac（空格）名称.java

运行

java（空格）名称 不带.java!!不带.java!!不带.java!!

方法定义*

定义格式：修饰符返回值类型方法名（参数列表）｛代码... return ; ｝

定义格式解释：修饰符：目前固定写法 public static 。返回值类型：目前固定写法 void ，其他返回值类型在后面的课程讲解。方法名：为我们定义的方法起名，满足标识符的规范，用来调用方法。参数列表：目前无参数，带有参数的方法在后面的课程讲解。 return：方法结束。因为返回值类型是void，方法大括号内的return可以不写。

注释

单行注释

//
多行注释键入/*

/*

我是多行注释

我是多行注释

*/
文档注释

对一段代码概括性的解释说明键入/**

/**

*我是文档注释

*我是文档注释

*/

标识符

类似 public、class、if 等

Java对大小写敏感
所有标识符都应以字母（A-Z或者a-z），美元（￥），下划线（_）开始
首字符后可为符合要求的任意组合
不能使用关键名作为变量名或方法名
不以数字作为开头
类名和接口名单词首字母尽量大写
常量名所有字母都要大写字母之间利用下划线链接： ZOE_SIMON_GULU
变量名和方法名第一个单词首字母小写从第二个开始大写： lineNumber
尽量使用有意义的英文作为变量名
合法标识符：_1、Ahello、ahello、$534、__123
不合法：1aur、-wwol、#3we、public

运算符

算术运算符

+-*/四则运算
++--自增自减 %求余
注意：计算顺序、两整数进行除法运算时会忽略小数部分
求余运算时：运算结果正负取决于%左数值，与其右侧数值无关。例如：（-5）%3 = -2 而5%（-3）= 2

自增自减：注意分清前后，若运算符在操作数前则先进行自增自减，若运算符在操作数后则先进性赋值后后进行运算

 public class Demo02 {
     public static void main(String[] args) {
         // ++ -- 自增  自减   一元运算符
         int a = 3;
         System.out.println(a);//3
         int b = a++;// a = a+1  先将a的值赋给b  此时b=3  赋值之后自增a=a+1
         System.out.println(a);//4  先赋值后自增  故输出a=4
         System.out.println(b);//3
         int c = ++a;//先自增后赋值  此前a=4 故先自增a=5  后将a=5的值赋给C  输出c=5
         System.out.println(a);//5
         System.out.println(b);//3
         System.out.println(c);//5
         System.out.println("================================================");
         //幂运算  Math.pow（2.4）返回值后如下*(不做基础要求)
         int _0 = 2*2*2*2;
         System.out.println(_0);
         double pow = Math.pow(2, 4);//16.0
         System.out.println(pow);
     }
 }

赋值运算符

=，+=，-=，*=，/=，%=
赋值、加等于、减等于、乘等于、除等于、模等于
以“+=”为例，“a+=3”即为“a=a+3”，其他依此类推

比较运算符

等于= 大于> 小于< 不等于!= 大于等于>= 小于等于<=
“=”为赋值运算符，“==”为比较运算符

逻辑运算符

&与 |或！非 ^异或 &&短路与 ||短路或

实例

    /*二元运算符
         * A = 1010 0011
         * B = 0011 0110
         * --  --  --  --  --
         * A&B 与 = 0010 0010
         * A|B 或 = 1011 0111
         * A^B 异或 = 1001 0101       相同为0 不同为1
         * ~B  非 = 1100  1001
         * 2*8 =16  表示为2*2*2*2
         * 位运算效率极高！！！
         * <<  左移  *2
         * >>  右移  /2
         * */
         System.out.println(2<<3);//2*2*2*2  即为左移三位

短路运算：短路与“&&”，若左边为false，则右边的表达式不再进行运算

短路或“||”，若左边为true，则右边的表达式不再进行运算

短路运算实例：

  //短路运算
         int s = 7;
         boolean x = (s<6)&&(s++<6);//&&时若（s<6）为false则后续运算不进行则s==7 
         System.out.println(s);//7  说明并未运算(s++<8)  若运算则s输出为8
         System.out.println(x);//false
         //注意： 短路与&&  短路或|| 均可进行短路运算  但是 与&  或|  不进行短路运算

运算符的优先级

优先级	运算符	结合性
1	()、[]、{}	从左向右
2	!、+、-、~、++、--	从右向左
3	、/、%	从左向右
4	+、-	从左向右
5	«、»、>>>	从左向右
6	<、<=、>、>=、instanceof	从左向右
7	==、!=	从左向右
8	&	从左向右
9	^	从左向右
10	\|	从左向右
11	&&	从左向右
12	\|\|	从左向右
13	?:	从右向左
14	=、+=、-=、*=、/=、&=、\|=、^=、~=、«=、»=、>>>=	从右到左

关键字

编程语言中（如Java）实现定义好并赋予了特殊含义的单词
例如： public（公共的） class（声明类） import（引入包） package（声明包）

注意：

所有关键字都是小写
不能使用关键字命名标识符

变量及常量

变量数据类型

强类型语言 Java
类型一：八大基本数据类型

（数值类型）整数类型范围大小：（1）byte<（2）short<（4）int<（8）long int 最常用 long数值尾端加上L ：默认int类型12

（数值类型）浮点类型：用于存储小数数值（4）float<（8）double float尾端数值加上F 默认double

e/E：1.5E（e）-45表示1.5*10的-45次方 e/E：以10 为底的指数

字符类型：char占两个字节 数值用单引号

布尔型：boolean：占一位，其值只有true和false两个表示正确错误

类型二：五种引用数据类型（不做基础学习）

类（class）接口（interface）数组枚举（enum）注解（annotation）

模板：数据类型变量名 = 值;

常量

上代码

 public class Demo01 {
     //static静态变量声明
     // final常量名称(修饰符，不区分先后)  一般大写字母定义常量
     static final double _1 = 1;//定义常量_1
     final static int num1 = 1999;//定义一个常量num1
     public static void main(String[] args) {
         System.out.println(num1);//1999
         System.out.println(_1+num1);//2000.0  double类型
     }
 }

字节

位（bit）：计算机内部最小储存单元11001100表示一个八位二进制数

字节（byte）：计算机中数据处理的基本单位，单位为B

1B（byte 字节）=8bit（位），即“一字节等于八位”

字符：计算机中使用的数字、字母、符号

1bit表示1位 1byte表示一个字节 1B=8bit 1024B=1KB 1024KB=1M 1024M=1G

作用域

局部变量、实例变量、类变量

 public class Demo06 {// 定义类
     final static double PI = 3.14;//实例变量：位于主程序方法外类中
     //若不进行初始化，则输出为该类型默认值 布尔值为false   0  0.0  除了基本类型，其余默认值均为nall
     static float salary =17000;  //类变量  位于类里面、下一行为主程序方法：main方法
     public static void main(String[] args) {// main方法
         String 人生得意须尽欢 = "莫使金樽空对月";//局部变量：位于主程序方法中  使用前先声明  并初始化值（赋一个具体的值）
         System.out.println(PI);
         System.out.println(salary);
         System.out.println(人生得意须尽欢);
     }
 }

数据类型转换

byte、short、char<int<long<float<long

自动转换

自动转换是Java自动执行的

 public static void main(String[] args) {
     int i = 1; 
     byte b = 2; 
     // byte x = b + i; 
     // 报错 
     //int类型和byte类型运算，结果是int类型 
     int j = b + i; 
     System.out.println(j);
     }

 public static void main(String[] args) { 
     int i = 1; 
     double d = 2.5; 
     //int类型和double类型运算，结果是double类型 
     //int类型会提升为double类型 
     double e = d+i; 
     System.out.println(e); 
 }

强制转换

强制类型转换：将取值范围大的类型强制转换成取值范围小的类型。强制转换需要我们自己手动执行。

转换格式：数据类型变量名 = （数据类型）被转数据值；

 public static class void main(string[] args){
     int a = 1;
         byte b = (byte)a;
     //byte优先级小于int   高到低需要进行强制转换
         System.out.println(b);
 }

内存溢出及精度问题

public static void main(String[] args) {
        //类型转换一：内存溢出
        int a = 127;
        //byte b = a;  错误原因：int容量高于byte，强制转换时先将a转换为byte类型
        byte b =(byte)a;
        System.out.println(a);
        System.out.println(b);//内存溢出

精度问题：当浮点数转换为整数型时会出现小数点后数据丢失

  System.out.println((int)11.3F);//输出11：精度问题
        System.out.println((int)99.9);//输出99

语句结构

顺序结构*

选择结构

if选择

if单选

        int _1 = 0;
        float _2 = 0.0F;
        int _3 = 2;
        if (_1==_2){//(语句为true则执行下行代码，为false则跳出选择)
            System.out.println(_3);//2
        }
if(条件语句){条件语句为true则执行代码块，为假则跳出语句
    代码块
}

if双选

 int _1 = 8;
        if (_1%2==0){
            System.out.println("这个数为偶数");
        }
        else{
            System.out.println("这个数为奇数");
        }//输出为“这个数为偶数”

if多选

 //评分等级标准A：100~90 B：90~80  C：80~70 D：70~60 不及格：<60 输入错误：t<0&&t>100
        int score = 97;
        if (score<100&&score>90){//判断条件1
            System.out.println("A级");//执行语句1
        }else if(score<90&&score>80){//判断条件2
            System.out.println("B级");//执行语句2
        }else if(score<80&&score>70){
            System.out.println("C级");
        }else if(score<70&&score>60){
            System.out.println("D级");
        }else if (score<60){
            System.out.println("成绩不合格");
        }else{
            System.out.println("所输入成绩不合法");
        }

Switch选择

使用switch关键字描述一个表达式，使用case关键字描述和表达式结果比较的目标值，当表达式的值与某个目标值匹配时则执行对应case下的语句
未找到任何匹配值则执行default下的语句，break关键字作用是跳出语句
case标签可以为字符串常量或字面量
switch中的变量类型可以是byte、int、short、char 字符串String

实例：

public static void main(String[] args) {
        int week = 7;
        switch (week){//表达式
            case 1://目标值1
                System.out.println("星期一");//执行语句1
                break;
            case 2://目标值2
                System.out.println("星期二");//执行语句2
                break;
            case 3:
                System.out.println("星期三");
                break;
            case 4:
                System.out.println("星期四");
                break;
            case 5:
                System.out.println("星期五");
                break;
            case 6:
                System.out.println("星期六");
                break;
            case 7:
                System.out.println("星期天");
                break;
            default:
                System.out.println("输入数据有误");
                break;
        }
    }

当两个及两个以上的case条件后的执行语句一样则只用书写一次
实例如下：

public static void main(String[] args) {
        int _1 = 3;//判断输入天数是否为休息日或者工作日
        switch (_1){
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                System.out.println("工作日");
                break;
            case 6:
            case 7:
                System.out.println("休息日");
                break;
        }
    }

选择结构案例：小明可以买什么

//case穿透性  break、defaul可选        
int book = 12;
        int pencil = 1;
        int rubber = 2;
        int cola = 3;
        int  snacks = 5;
        int left = 20-book;
        System.out.println("您一共有20元，书本价格为"+book+"元");
        System.out.println("1.铅笔的价格为"+pencil+"");//1
        System.out.println("2.橡皮的价格为"+rubber+"");//2
        System.out.println("3.可乐的价格为"+cola+"");//3
        System.out.println("4.零食的价格为"+snacks+"");//4
        Scanner str = new Scanner(System.in);
        System.out.println("请输入你需要的商品序号：");
        int _1 = str.nextInt();
        switch (_1){
            case 1://购买铅笔  一元一支
                Scanner num1 = new Scanner(System.in);
                System.out.println("铅笔的价格是"+pencil+"元，买完书后剩余"+left+"元！请选择要购买的数量：");
                int _2 = num1.nextInt();
                int _3 = 8-_2;
                System.out.println("你购买了"+_2+"支铅笔，剩余"+_3+"元");
                break;
            case 2://购买橡皮  两元一块
                Scanner num2 = new Scanner(System.in);
                System.out.println("橡皮的价格是"+rubber+"元，买完书后剩余"+left+"元！请输入要购买的数量：");
                int _4 = num2.nextInt();//定义用户输入的数据（购买橡皮数量）
                int net = 2*_4;//购买橡皮总金额
                int net2 = 8-net;
                if (net<=8&&net>=0){
                    System.out.println("你购买了"+_4+"个橡皮，剩余"+net2+"元");
                }
                else{
                    System.out.println("你的钱不够了！！！");
                }
                break;
            case 3://购买可乐 三元一瓶
                Scanner num3 = new Scanner(System.in);
                System.out.println("可乐的价格是"+cola+"元，买完书后剩余"+left+"元！请输入要购买的数量：");
                int nat1 = num3.nextInt();//可乐数量
                int nat2 = 3*nat1;//总金额
                int nat3 = left-nat2;
                if (nat1<=2&&nat1>=0){
                    System.out.println("你购买了"+nat1+"个可乐，剩余"+nat3+"元");
                }else{
                    System.out.println("你的钱不够了！！！");
                }
                break;
            case 4://购买零食  五元一袋
                Scanner num4 = new Scanner(System.in);
                System.out.println("零食的价格是"+snacks+"元，买完书后剩余"+left+"元！请输入要购买的数量：");
                int snk = num4.nextInt();
                int snk1 = 5*snk;
                int snk2 = left-snk1;
                if (snk==0||snk==1){
                    System.out.println("你购买了"+snk+"份零食，剩余"+snk2+"元");
                }else{
                    System.out.println("你的钱不够了！！！");
                }
                break;//可选  
            default://可选
                System.out.println("输入数据有误");
                break;
        }

循环结构

while循环

while循环一般用于未知循环次数

//计算1+2+3+4...+99+100？
    public static void main(String[] args) {
        int a =0;
        int plus = 0;
        while (a<=100){//循环条件
            plus += a;//循环体
            a++;
        }
        System.out.println(plus);//5050
    }

do.....while循环

do...while循环体至少无条件执行一次

 public static void main(String[] args) {
        int a = 0;
        int b = 0;
        while (a<0){
            a++;
        }
        System.out.println(a);//0
        System.out.println("==================================");
        do {
            b++;
        }while (b<0);
        System.out.println(b);//1  
    }

for循环

一般用于已知循环次数
格式：

for(①初始化表达式;②循环条件;③操作表达式;){
    循环体④;
    ...
}

第一步：执行① 第二步：执行②，条件成立则执行第三步（④）。不成立则跳出循环

第三步：执行④ 第四步：执行③，然后重复第二步第五步：退出循环

 public static void main(String[] args) {
        int b=0;
        for (int a=0;a<=100;a++){
            b+=a;
        }
        System.out.println(b);
    }

嵌套循环

定义：指在一个循环语句内再定义一个循环语句的语法结构

while、do...while、for循环都可以在使用时进行嵌套

此处利用两个for循环进行嵌套：

public static void main(String[] args) {           //输出
        int i, j;   //定义两个循环变量              //*
        for (i = 1; i <= 9; i++) { //外层循环      //**
            for (j = 1; j <= i; j++) {//内层循环   //***
                System.out.print("*");//输出*     //****
            }                                    //*****
            System.out.print("\n");//换行        //*******
        }                                       //********
    }                                           //*********

//会进行自动换行   println相当于print加上\n的效果

 public static void main(String[] args) {//九九乘法表
         for (int i=1;i<=9;i++){
             for (int j=1;j<=i;j++){
                 System.out.print(j+"*"+i+"="+"i*j"+"\t");
             }
             System.out.println();
         }
     }

跳转语句（break、continue）

break

在switch条件语句以及循环语句中都可以使用break语句
switch：break用于种植某个case并且跳楚switch结构

循环：用于跳出循环语句，执行循环后代码

 public static void main(String[] args) {
         int i = 0;
         for (i=0;i<=9;i++){   
             if (i==7){
                 break;    //i=7跳出循环
             }
             System.out.println(i);//0123456
         }
         System.out.println("=============================================");
         System.out.println(i);//7
     }

continue

continue用作循环语句当中，它的作用是终止本次循环

实例（计算100内奇数之和）：

  //100以内奇数之和
     public static void main(String[] args) {
         int sum = 0;
         for (int i = 1; i<=100;i++){
             if (i%2==0){
                 continue;//跳出本次循环
             }else{
                 sum += i;
             }
         }
         /*for (int i = 1;i<=100;i++){
             if (i%2==0){
                 continue;
             }
             sum +=i;
         }*/
         System.out.println(sum);//2500
     }

扩展：三元运算符

格式：判断条件？表达式1 ：表达式2

实例：

 public class Demo03 {
     public static void main(String[] args) {
          int salary =7000;
         //三元运算符  a ？ b : c; 若a为真则输出b，a为假输出b；
         String simon = salary<10000 ?  "普通" : "小康";//类似if循环语句
         System.out.println(simon);//输出“普通”
     }
 }

代码细节

整数类型中long类型须在数值尾部加上字母 L
浮点类型中float类型须在数值尾部加上字母 F
//数值类型变量名 = 数值；
String（属于类）：后数值需加双引号
字符类型char：后数值需加单引号

数据类型扩展

整数类型

进制：二进制0b 八进制0 十进制 十六进制0x
浮点类型拓展

float：离散有限舍入误差约等接近但不等于（不用于银行进行货币计算）

布尔型拓展（boolean）

 boolean Simon = true;
   if (simon==true){
       执行语句1
   }    
 //此为初学者 小括号内语句默认为true  因此不用再强调
   if (simon){
       执行语句1
   }
 // 此操作熟练后可使用

字符拓展（char）

部分特殊字符*：\n换行符 \u数字字符转换