JAVASE第二章(基础)


前言、

本文章是JavaSE的基础语法部分,属于Java入门起步课程,对于后续Java的高级概念的学习有非常重要的影响。涉及到的内容有:变量与常量,标识符,关键字,运算符,Java的数据类型,条件分支语句,循环语句,跳转语句等.


一、IDE使用

IDE(Integrated Development Environment )集成开发环境,是用于提供程序开发环境的应用程序一般包括代码编辑器、编译器、调试器和图形用户界面等工具。
常用的JAVA开发工具有:IntelliJ IDEA (免费下载 使用收费),Eclipse (完全免费)。


二、注释

使用的特定的符号标记的内容,对代码功能的解释。

int a=0     //单行注释

/*int b=1;
int c=0;   多行注释*/    

/**
*文档注释:用于为类,成员变量,方法的功能进行说明,在调用时可以提示
*/

三、关键字

Java中被赋予特定含义的单词,主要用来修饰包,类,变量,方法。

注意:关键字中所有字母都为小写
在这里插入图片描述
在这里插入图片描述


四、保留字

Java保留字:现有Java版本尚未使用,但以后版本可能会作为关键字使用。自己命名标记符时要避免使用这些保留字 goto 、const


五、标识符

JAVA 对各种变量、方法和类等要素命名时使用的字符序列称为标识符.

1、定义合法标识符规则

1.由26个英文字母大小写,0-9 ,_或 $ 组成 数字不可以开头。
2.不可以使用关键字和保留字,但能包含关键字和保留字。
3.Java中严格区分大小写,长度无限制。
4.标识符不能包含空格。
注意:在起名字时,为了提高阅读性,要尽量有意义,“见名知意”。

2、Java中的名称命名规范

1.包名:多单词组成时所有字母都小写:xxxyyyzzz
2.类名、接口名:多单词组成时,所有单词的首字母大写:XxxYyyZzz
3.变量名、方法名:多单词组成时,第一个单词首字母小写,第二个单词开始每个单词首字母大写:xxxYyyZzz
4.常量名:多单词时每个单词用下划线连接,XXX_YYY_ZZZ


六、JAVA变量

变量:程序中基本的存储单元,运行时值可变,其要素包括变量名,变量类型,使用变量名来访问这块区域。
变量在使用前必须对其声明,例如:

int i = 100; 
int i1, i2, i3 = 10;
String s = “hello”;

注意:本质上,变量其实是内存中的一小块区域,使用变量名来访问这块区域,因此,每一个变量使用前必须要先申请(声明),然后必须进行赋值(填充内容),才能使用。


六、基本数据类型

1、数据类型

程序中对于每一种数据都定义了明确的具体数据类型,在内存中分配了不同大小的内存空间
在这里插入图片描述

public static void main(String[] args) {
        byte a=127;  //byte b=128; 超出范围
        long d=123334345451L;// long c=123452121212; 错误,没有加L
        int  e=011;       //八进制以0开头
        System.out.println(e);
        int f=0b11;      //二进制以0b或者0B开头
        System.out.println(f);
        int g=0x11;     //十六进制以0X或者0x开头
        System.out.println(g);
        float h=1.2f;  //float  j=1.2;   错误形式,没有加f;
        double k=12324.5;      //Java 浮点型常量默认为 double 型,如要声明一个常量为 float 型,则需在数字后面加 f 或 F
    }

2、基本数据类型和引用数据类型的区别

1.声明变量时不同的内存分配: 
基本类型值:存储在栈中的简单数据段,也就是说,它们的值直接存储在变量访问的位置。
引用类型值:存储在堆中的对象,也就是说,存储在变量处的值是一个指针,指向存储对象的内存地址。

2.复制变量时的不同
基本类型值:将一个变量复制给另一个变量时,这两个变量是完全独立的,他们只是拥有相同的value而已。
引用类型值:将一个变量复制给另一个变量时,会把这个内存地址赋值给新变量他们中任何一个作出的改变都会反映在另一个身上。

3、基本数据类型所占空间大小

byte b: 1字节
short s:2字节
int i:4字节
long l: 8字节
char c:2字节(C语言中是1字节)
float f: 4字节
double d: 8字节
boolean bool:false/true 1字节

4、ASCII 码

ASCII码:在计算机内部,所有数据都使用二进制表示。每一个二进制位(bit)有 0 和 1 两种状态,因此 8 个二进制位就可以组合出 256 种状态,这被称为一个字节(byte)。一个字节一共可以用来表示 256 种不同的状态,每一个状态对应一个符号,就是 256 个符号,从 0000000 到 11111111。

ASCII(ASCII American Standard Code for Information Interchange,美国信息互换标准代码)
上个世纪60年代,美国制定了一套字符编码,对英语字符与二进制位之间的关系,做了统一规定。这被称为ASCII码
ASCII码一共规定了128个字符的编码,比如空格“SPACE”是32(二进制00100000)大写的字母A是65(二进制01000001)
这128个符号(包括32个不能打印出来的控制符号),只占用了一个字节的后面7位,最前面的1位统一规定为0

缺点:不能表示所有字符。


七、基本数据类型转换

Java中可以从任意基本类型转型到另外的基本类型 (boolean 类型不可以转换为其他的数据类型。)
转换分为默认转换和强制转换

1、默认转换

整形,字符型,浮点型的数据在混合运算中相互转换,转换时遵循以下原则:容量小的类型默认转换为容量大的数据类型(数据类型按容量大小排序为: byte,short,char->int->long->float->double)
注意:有多种类型的数据混合运算时,系统首先自动的将所有数据转换成容量最大的那一种数据类型,然后再进行计算。

2、强制转换

1、byte,short,char之间不会互相转换,他们三者在计算时首先会转换为int类型强制转换。
2.容量大的数据类型转换为容量小的数据类型时,要加上强制转换符,但可能造成精度降低或溢出;使用时要格外注意。

    public static void main(String[] args) {
        /*
           默认转换
             byte,short,char-->int-->long-->float-->double
             容量小的数据类型  默认自动转为容量大的
         */
          byte b=127;
          int c= 2147483647;
          long d = c;
          float f = d;

          /*
          容量大的 转为 容量小的
           强制类型转换
             问题:
               数据溢出
               精度损失
           */

          int x = 258;
          byte y = (byte)x;
        System.out.println(y);

          float m = 10.5F;
          long n = (long)m;
        System.out.println(n);

    }

八、运算符

Java 语言支持如下运算符:
1.算术运算符: +,-,,/,%,++,-
2字符串连接运算符:+
3关系(比较)运算符: >,<,>=,<=,==,!=
4逻辑运算符: !,& , | , &&,||
5赋值运算符: = ,+ =,- =,
=,/ =
6条件运算符 :类型 结果 = (条件表达式)?表达式1:表达式2
7位运算符 :<< >> >>> & | ^ ~

1、算数运算符

/*
  算术运算符
   + - * / % ++ --
   + 加法  字符串连接
   - * / % 只能进行算数运算
 */
public class OperateDemo1 {

    //java程序的入口/主方法/主线程
    public static void main(String[] args) {
             int a = 10;
             int b = 5;
             char c  = 'd';//100
             String d = "100";
             String e = "aa";
        System.out.println(a+b);
        System.out.println(a+c);//整数+char(int)
        System.out.println(a+b+d);// 数值+(连接)字符串==字符串
        System.out.println(d+e);//字符串+字符串=字符串
        System.out.println(a-b);
        System.out.println(a-c);
        //System.out.println(a-d);

        //++  每++一次 在原来的基础上+1 再赋值
        //单独使用时++在前/后没有区别,在混合运算时++在前先自增后运算,反之则先运算后自增
        // --
        int x = 5;
            //x++;//x=x+1  6
            //++x;//x=x+1  7
        //int y = x++;
        int y = ++x;
        System.out.println(x);//6
        System.out.println(y);//6
    }
}

2、比较运算符

/*
   比较运算符
   ==
   !=  数值,布尔,引用类型
   > < >= <= 适用于数值类(char)
   instanceof 类型检测
 */
public class OperateDemo2 {

    //java程序的入口/主方法/主线程
    public static void main(String[] args) {
        //==
        int a = 10;
        int b = 5;
        boolean c = true;
        boolean d = false;
        String e = "abc";
        String f = "efg";
        System.out.println(a==b);
        System.out.println(c==d);
        System.out.println(e==f);
        //!=
        System.out.println(a!=b);
        System.out.println(c!=d);
        System.out.println(e!=f);

       /* System.out.println(e>f);
        System.out.println(c>e);*/

        Object x = 10;
        //Object类型可以表示任何类型,但是实际表示的是哪种类型呢?
        System.out.println(x instanceof Integer);
    }
}

比较运算符的结果都是boolean型,也就是要么是true,要么是false。
注意:比较运算符“==”不能误写成“=”

3、逻辑运算符

/*
    逻辑运算符
     &       |        !     ^  可以参与逻辑运算还可以参与位运算
     逻辑运算: true & false
     位运算: 二进制bit位运算  6 & 3

     &&(短路与)   ||(短路或)

 */
public class OperateDemo3 {

    //java程序的入口/主方法/主线程
    public static void main(String[] args) {
         int a = 10;
         int b = 5;
         int c = 6;
         int d = 20;

       /* //& 左右都为true 结果为true  遇到第一个false时,后面的表达式继续执行
        System.out.println(a>b&b<c);//true & true = true
        System.out.println(a>b&b>c);//true & false = false
        System.out.println(a<b&b>c);//false & false = false

        //&&左右都为true 结果为true   遇到第一个false时,就发生短路,后面的表达式就不在执行了
        System.out.println(a>b&&b<c);//true && true = true
        System.out.println(a>b&&b>c);//true && false = false
        System.out.println(a<b&&++b>c);//false && false = false
        System.out.println(b);*/

        //| 只要有一为true 结果为true
        System.out.println(a>b|b<c);//true | true = true
        System.out.println(a>b|b>c);//true | false = true
        System.out.println(a<b|b>c);//false | false = false

        //||只要有一为true 结果为true 只要遇到第一个true 后面的表达式就不行了
        System.out.println(a>b||b<c);//true || true = true
        System.out.println(a>b||++b>c);//true || false = true
        System.out.println(a<b||b>c);//false || false = false
        System.out.println(b);

       /* //!
        System.out.println(!(a>b));
        
        //^  异或运算  相同为false  不同为true
        System.out.println(a>b^b<c);//true ^ true = false
        System.out.println(a>b^b>c);//true ^ false = true
        System.out.println(a<b^b>c);//false ^ false = false*/
    }
}

1.“&”和“&&”的区别:单&时,左边无论真假,右边都进行运算;双&时,如果左边为真,右边参与运算,如果左边为假,那么右边不参与运算。
2.“|”和“||”的区别同理,||表示:当左边为真,右边不参与运算。
3.异或( ^ ):当左右都为true时,结果为false ,追求的是“异”!

4、赋值运算符

/*
   赋值运算符
   =  注意在赋值时,值的类型与声明的变量类型一致.
      牵扯到数据类型的转换(基本类型之间) 自动转换,强制转换
   扩展赋值运算
   +=
   -=
   *=
   /=
   %=
 */
public class OperateDemo4 {

    //java程序的入口/主方法/主线程
    public static void main(String[] args) {

         byte a = 12;//隐式的将int12 转为 byte
         int b = a;
         short c = (short)b;

         float d = 10.5f;
         int e = (int)(c+b+d);//混合运算时,数据类型默认会转为表达式中最大的类型

       /* int x = 5;
        long y = 10;
            x += y; // x=x+y
        System.out.println(x);*/

        short s = 3;
              //s=s+2; s = short+ int = int
              s+=2;//隐式转换 short + int = short


    }

符号:= 当“=”两侧数据类型不一致时,可以使用自动类型转换或使用强制类型转换原则进行处理。支持连续赋值。
扩展赋值运算符: +=, -=, *=, /=, %=
思考1:
short s = 3;
s=s+2; ①
s+=2; ②
①和②有什么区别?
解答:
s+=2会有一个隐式转换,short+int=short不会报错
s=s+2不会转换 short+ int = int 赋值给short类型的s时会报错

5、条件运算符

package day2;
public class OperateDemo4 {
    public static void main(String[] args) {
        int a=60;
        String b=(a>=60)?"及格":"不及格";
       // int b=(a>=60)?"及格":"不及格"; 报错  b和表达式类型不同;
       //  String c=(a>=60)?"及格":100;   报错 表达式1和表达式2的类型不同;
        System.out.println(b);
    }
}

条件运算符(3元运算符)
类型 结果 = (条件表达式)?表达式1:表达式2
必须返回一个结果,结果的类型与定义结果类型一致

6、位运算符

/*
    位运算符, 二进制的bit位的运算
    <<
    >>
    >>>
    &
    |
    ^
    ~
 */
package day2;
public class OperateDemo5 {
    public static void main(String[] args) {
        //int a=6;
        //   a=a<<1;   左移一位 结果为12
        //System.out.println(a);
        //a=a>>1;     右移一位,结果为3;
        // System.out.println(a)
        /*int b=-1;
        b=b>>>1;
        System.out.println(b);    无符号右移,无论正数还是负数,空位都用0补*/
      /*   int a=6;
        int b=4;
        System.out.println(a+" "+b);
        a=a^b;
        b=a^b;
        a=a^b;
        System.out.println(a+" "+b);   用异或操作来调换两个数字的值*/
        /*int a=6;
        a=~a;
        System.out.println(Integer.toBinaryString(-7));*/
    }
}

利用位运算符中的异或操作可以交换两个变量的值


九、表达式的运算顺序

在这里插入图片描述


十、控制台输入

使用标准输入串System.in 使用Scanner取得一个字符串或一组数字
在新增一个Scanner对象时需要一个System.in对象,因为实际上还是 System.in在取得用户输入。

next()方法用以取得用户输入的字符串;
nextInt()将取得的输入字符串转换为整数类型
nextFloat()转换成浮点型;
nextBoolean()转 换成布尔型。
package day2;
import java.util.*;
public class ScannerDemo {
    public static void main(String[] args) {
        Scanner sb=new Scanner(System.in);
        String a=sb.nextLine();   //阻塞式
        System.out.println(a);
        int age=sb.nextInt();
        System.out.println(age);

    }
}

十一、控制语句

1、If条件结构

public class IfDemo {
    public static void main(String[] args) {
        int a=59;
        if(a>=60){
            System.out.println("及格");
        }
        else{
            System.out.println("不及格");
        }

        if(a>80){
            System.out.println("优秀"); }
        else if(a>=60){
            System.out.println("及格"); }
        else{
            System.out.println("不及格");
        }
    }
}


2、分支和循环结构

import java.util.*;
public class SwitchDemo {
    public static void main(String[] args) {
        Scanner sb=new Scanner(System.in);
        int a=sb.nextInt();
        while(a!=8){
        switch(a){
            case 1: System.out.println("星期一"); break;
            case 2: System.out.println("星期二");break;
            default: System.out.println("其他");
        }
        a=sb.nextInt();
        }
    }
}

switch语句:多分支选择语句,根据表达式的值,来执行多个操作中的一个。

1.表达式可以是byte、short、int、char、枚举类型。JDK 7以后,可以使用String类型;
2.case语句后面只能使用常量表达式; case后的值不能重复;
3.某个case分支如果没有提供break语句,**则继续执行下一个case后的语句;
4.当表达式的值与任一case子句中的值都不匹配时,将执行default后面的语句;
5.如果没有default子句,则程序直接跳出switch语句。

3、switch和if语句的对比

if和switch语句很像,具体什么场景下,应用哪个语句呢?

1.如果判断的具体数值不多,而且符合byte、 short 、int、 char这四种类型,建议使用swtich语句。因为效率稍高。
2.其他情况:对区间判断,对结果为boolean类型判断,使用if,if的使用范围更广。

4、while和do-while语句

在这里插入图片描述


5、For循环

For语句为如下形式:

for(表达式1; 表达式2; 表达式3){ 
     语句1; 
     语句2;
     ....; 
}

执行过程:
 1.首先计算表达式1
 2.接着执行表达式2,若表达式2的值 = true,则执行循环语句
 3.接着计算表达式3,再判断表达式2的值;
 4.依此重复下去,直到表达式2的值=false
for (int i = 1; i <=9; i++) {       //打印99乘法表
    for(int j=1;j<=i;j++){
            System.out.print(j+"*"+i+"="+i*j+"\t");
     }
        System.out.println();      
}

6、break和continue

break 语句用于终止某个语句块的执行。用在循环语句体中,可以强行退出循环;例如:

int stop = 4;
for (int i = 1; i <= 10; i++)
 {                                     //当i等于stop时,退出循环
   if (i == stop){                
     break;
 }

continue 语句用在循环语句体中,用于终止某次循环过程,跳过循环体中 continue 语句下面未执行的循环,开始下一次循环过程;例如:

int skip = 4;
for (int i = 1; i <= 5; i++) {
                                       //当i等于skip时,跳过当次循环
   if (i == skip){        
    continue;
   }
   System.out.println("i = " + i);
}

7、嵌套循环

1.将一个循环放在另一个循环体内,就形成了嵌套循环。其中, for ,while ,do…while均可以作为外层循环和内层循环。
2.实质上,嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时,才会完全跳出内层循环,才可结束外层的当次循环,开始下一次的循环。
3.结束外层循环:如果需要从多层循环跳出,则需要使用标签,定义一个标签,如label,然后在需要跳出的地方,用break label就行了.

   public static void main(String[] args) {
        /*for (int i = 0; i < 5; i++) {
            for(int j=0;j<5;j++){
                System.out.print("*");
            }
            System.out.println();
        }*/
       /* 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();
        }*/
    /* for (int i = 0; i < 5; i++) {
            for(int j=0;j<5;j++){
                if(j==3)
                    break;
                System.out.print(j+" ");
            }
            System.out.println();

        }*/
     out:for (int i = 0; i < 5; i++) {     //标记外层循环然后用break结束;或者直接用return语句暴力结束;
            for(int j=0;j<5;j++){
                if(j==3)
                    break out;
                System.out.print(j+" ");
            }
         System.out.println();
        }
    }
}


十二、JAVA中的方法

Java的方法类似于其它语言的函数,方法是解决一类问题的步骤的有序组合, 方法包含于类或对象中.

方法在程序中被创建,声明格式:

[访问权限修饰符 修饰符…] [返回值类型] 方法名(形式参数类型 参数名){
Java语句;
[return 返回值;]
}

1.修饰符:这是可选的,告诉编译器如何调用该方法。定义了该方法的访问类型。
2.返回值类型:事先约定的返回值的数据类型,如无返回值,必须给出返回值类型void。
3.形式参数: 在方法被调用时用于接收外界输入的数据。
4.实参:调用方法时实际传给方法的数据。
5.返回值:方法在执行完毕后返还给调用它的环境的数据。
public class Method1 {
    public static void main(String[] args) {
     Method1 method=new Method1();
     method.method1();
     method.printStar(3,3);
     int c=method.max(10,5);
     double d=method.max(1.0,2.0);
     System.out.println(d);
    }
    public void method1(){
        System.out.println("调用了method1方法");
    }
    public void printStar(int row,int clo) {   //实参和形参要一致
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < clo; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
    public int max(int a,int b){   //注意返回值类型要一致
        int c= a>b?a:b;
        System.out.println(c);
        return c;
    }
    public double max(double a,double b){    //方法的重载
        return a>b?a:b;
    }
}


public class Test {
    public static void main(String[] args) {
        Method1 method=new Method1();    //测试method类
        method.method1();
        int c=method.max(1,2);
        double d=method.max(1.0,2.0);
        method.printStar(5,5);
    }
}



注意:
Java语言中使用下述形式调用方法:对象名.方法名(实参列表)
• 实参的数目、数据类型和次序必须和所调用方法声明的形参列表匹配
• return 语句终止方法的运行并指定要返回的数据。


总结、

JAVA基础语法对以后JAVA高级概念的学习有着举足轻重的影响,所谓树高千丈,根源还是在底部。
希望大家能够认识到JAVA基础语法的重要性,理解知识点并且可以讲解,重复练习加深印象。在这里插入图片描述

  • 12
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 11
    评论
评论 11
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

JinziH Never Give Up

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值