[Java知识库]Java程序设计基础 (基础知识通俗易懂)

前言

本篇主要总结一些Java基础知识，都是一些常见的知识，通俗易懂，很好理解的，总结的不好，多多谅解，希望能对新手有所帮助。

一标识符和关键字

1.标识符的定义

在程序设计中，为程序的各个元素进行命名，这种命名的记号就是标识符。

注意：
1.标识符是以字母或（_）下划线（$)美元符号等开始的字符序列。
2.标识符开头第一个字符不能是数字，后面不能包含一些特殊字符和运算符。

合法的标识符有：
Boy，_test, $good 等

不合法的标识符有：
class，7Cat，hi*，#world 等

2.关键字

关键字是Java中具有特殊含义的字符序列。

注意：
所有的关键字都是小写的。
1.定义类型的关键字
byte，short，int, long, float, double, char. boolean。
2.流程控制的关键字
if…else, switch, case, default, do…while, for, break, continue。
3.方法类型变量的修饰关键字
private, public, protected, final, static, abstract, synchronized, volatile。
4.异常处理关键字
try, catch, finally, throw, throws。
5. 对象相关关键字
new, extends, implements, class, instanceof, this, super。
6.字面常量关键字
false, true, null。
7.方法相关关键字
return, void。
8.包相关关键字
package, import。

3.注释

注释可以增加可读性，系统不会对注释内容进行编译。

1.单行注释
格式：//注释内容

2.多行注释
格式：
/* 注释内容 */

3.文档注释
格式：/** 注释文本 */

二.常量和变量

1.常量

一般常量标识符全部用大写字母，如果多个单词组成用下划线连接。
例如：int MAX_COUNT=100；

2.变量

变量的值可以修改。
格式如下：

[修饰符] <类型名> <变量名> [=<初值>]；

下面可以用一个案例来说明：

package cn.itcast.lesson;
public class lesson1 {
    public static void main(String[] args) {
        int x=1;
        System.out.println(x);
    }
}

程序运行结果：1

三.基本数据类型

JAVA的数据类型分为两类：基本数据类型和引用数据类型。

1.整数类型

1.1Java定义了四种类型：

            byte， short，int，long。

1.2在表示long型常量时，需要在后面加上后缀L或l。
例如：long j=100 L；

1.3整数有三种进制形式表示：

a.十进制：首位不能为0，且用0-9的数字表示。如：159，-500。

b.八进制：以0开头，后面跟0-7的数字表示。如：0123。

c.十六进制：以0x或0X开头，后跟0-9的数字或者A-F之间的字母表示。
如：0x12AB

d.二进制：以0b或0B开头，后跟0-1之间的数字。

2.布尔类型

布尔类型用关键字boolean表示，只有true和false两个值。

例如：boolean a=true；

3.浮点类型

JAVA用浮点数表示数学中的实数，有整数部分和小数部分。

一个浮点数默认为double型，在一个浮点数后加一个字母F或f，表示float类型。
例如：

                 2.1  是double型
                 2.1F  是float型

4.字符类型

a.字符常量

字符常量是用单引号括起来的一个字符。例如 ： ‘D’。

用双引号括起来的是字符串。例如：“HelloWorld”

b.字符变量

字符类型变量用char表示。

例如：char x；

5.各类型间的转换

a.自动类型转换

从低级到高级会自动类型转换
从低到高顺序为：

              byte-short-char-int-long-float-double

b.强制类型转换

从高级到低级数据类型转换需要强制类型转换。
例如：把int型转换为char型

          int    x=3；
           char    y；
           y=（char)x;

四.运算符

运算符负责对数据进行运算和处理。

1.算术运算符

算数运算符主要用于整型和浮点类型的运算。

a.下面通过案例来分析算数运算符的运算规则：

package cn.itcast.lesson;
public class lesson2 {
    public static void main(String[] args) {
        int x=7;
        int y=5;
        System.out.println(x+y);    //输出12
        System.out.println(x-y);    //输出2   
        System.out.println(x*y);    //输出35
        System.out.println(x/y);    //输出1
        System.out.println(x%y);    //输出2
        //下面是整型和浮点型结合运算
        System.out.println(7.0+3);   //输出10.0
        System.out.println(5.0/4);   //输出1.25
    }
}

运行结果为：

注意：

   两个整数乘除加减还是整数。
   想要得到小数必须有浮点数参与运算。

b.通过案例来分析自增自减的运算规则，再此就以自增为例。

package cn.itcast.lesson;

public class lesson2 {
    public static void main(String[] args) {
        int x=7;
        System.out.println(x++);   //输出7
        System.out.println(++x);   //输出8
    }
}

运行结果为：7 8

由此得出结论：

                    ++在后先赋值后自增，
                    ++在前先自增后赋值。

c. 字符串和字符的加法运算 。

package cn.itcast.lesson;
public class lesson2 {
    public static void main(String[] args) {
       
        //字符串与字符的加法运算 
        System.out.println("Tom"+"Jack");
        System.out.println(3+"Tom");
        System.out.println(3+3+"Tom");
        System.out.println("Tom"+3+3);

    }
}

运行结果为：

注意：

  两边都是字符串时进行字符串拼接。
   混合运算时，运算规则是从左到右。

2.赋值运算符

a.基本赋值运算符
格式：

<变量名>=<表达式>

通过案例分析：

package cn.itcast.lesson;
public class lesson2 {
    public static void main(String[] args) {
        int x,y;
        x=10;
        System.out.println(y=x+10);
    }
}

运算结构为：20

b.扩展赋值运算符
运算符有：

+=   -=   *=   /=     %=

通过案例分析：

package cn.itcast.lesson;
public class lesson2 {
    public static void main(String[] args) {
        int x=10;
        x+=3;
        System.out.println("x+=3: "+x);
    }
}

运行结果为：13
其他的你可以自己实操一下，加深一下印象。

3.条件运算符

格式：

（关系表达式）？ 表达式1：   表达式2：

执行流程为：

先判断条件是否成立，如果成立，执行表达式1。如果不成立，执行表达式2。
具体用法看案例：

package cn.itcast.lesson;
public class lesson2 {
    public static void main(String[] args) {
        int x=10;
        int y=5;
        int z=(x>=y) ? x: y;
        System.out.println("z: "+z);
    }
}

运行结果为：

4.关系运算符

关系运算符用来比较两个值的大小，结果返回布尔值：true或者false。

关系运算符有六种如下：

案例如下：（注意：关系运算结果是true或者是false。）

package cn.itcast.lesson;
public class lesson2 {
    public static void main(String[] args) {
        int x=10;
        int y=15;
        System.out.println(x==y);
    }
}

运行结果：

5.逻辑运算符

逻辑运算又称布尔运算，只能处理布尔类型数据，所以结果是布尔值。

或 的运算符号为 ||（表格里打不出来，哈哈哈）

案例如下：

package cn.itcast.lesson;
public class lesson2 {
    public static void main(String[] args) {
        int x=5;
        int y=10;
        System.out.println((x>6) || (y<34));
    }
}

运行结果为：

五.程序控制语句

JAVA程序控制语句分为三类：选择，循环，跳转语句。

1.if语句

if语句是JAVA中的条件分支语句，将程序的执行路径分为两条。
格式如下：

if（判断条件）
{
   执行语句
}
else
{
   执行语句
}

if语句执行过程是：

 如果条件为真，执行 if 后面的语句，如果为假执行 else 后面的语句。

if 语句具体流程图就不写了，可以参照我专栏C语言里写的流程图：点击直接查看

通过简单的案例来分析：

public class lesson2 {
    public static void main(String[] args) {
        int x=10;
        int y=100;
        if(x>y)
        {
            System.out.println("x>y");
        }
        else
        {
            System.out.println("x<y");
        }
    }
}

运行结果：x<y
分析：首先判断条件，上述代码可知 x>y 是不成立的，所以执行else后面的执行语句。

还有一种嵌套形式，语法格式如下：

if (判断条件1)
{
  执行语句1
}
else if (判断条件2)
{
   执行语句2
}
...............
else if (判断条件n)
{
   执行语句n
}
else 
{
 执行语句n+1
}

if 语句嵌套形式，一旦找到真的条件，就执行与它关联的语句，要是所有条件都不满足，则执行else语句。

if 嵌套语句具体流程图就不写了，可以参照我专栏C语言里写的流程图：点击直接查看

案例：判断某个月是什么季节。

public class lesson2 {
    public static void main(String[] args) {
        int month=6;
        String season;
        if(month==12 || month==1 || month==2) {
            season = "冬天";
        }
        else if (month==3 || month==4 || month==5)
        {
            season="春天";
        }
        else if (month==6 || month==7 || month==8)
        {
            season="夏天";
        }
        else if (month==9 || month==10 || month==11)
        {
            season="秋天";
        }
        else
        {
            season="输入的月份不正确！";
        }
        System.out.println("季节是: "+season);
    }
}

运行结果为：

2.switch语句

switch语句是JAVA中的多分支语句，它基于表达式的值使程序执行不同语句序列。

格式如下：

switch （）
{
  case 目标值1:
  执行语句1
  break;
  case 目标值2:
  执行语句2
  break;
  ...........
  ...........
  case 目标值n:
  执行语句n
  break;
  default:
  执行语句 n+1
  break;  
}

switch语句具体流程图就不写了，可以参照我专栏C语言里写的流程图：点击直接查看

注意：

     break表示中断，结束switch语句。
     default表示所有情况不匹配的时候，就执行该处的内容。

案例：判断某个月是什么季节。（结合着 if 嵌套语句看）

public class lesson2 {
    public static void main(String[] args) {
        int month = 6;
        String season;
        switch(month)
        {
            case 12:
            case 1:
            case 2:
                season="冬季";
                break;
            case 3:
            case 4:
            case 5:
                season="春季";
                break;
            case 6:
            case 7:
            case 8:
                season="夏季";
                break;
            case 9:
            case 10:
            case 11:
                season="秋季";
                break;
            default:
                season="输入的月份错误";
        }
        System.out.println("季节是："+season);
    }
}

运行结果为：

注意：如果没有break语句，程序将执行下面每一个case语句。

3.while语句

while语句是JAVA最基本的循环语句，当它的条件表达式是true时，while语句重复执行循环体。

格式如下：

while（循环条件）
{
   执行语句
   .......
}

while语句具体流程图就不写了，可以参照我专栏C语言里写的流程图：点击直接查看

案例：计算1-100的数的和。

public class lesson2 {
    public static void main(String[] args) {
        int sum=0,i=1;
        while(i<=100)
        {
            i++;
            sum+=i;
        }
        System.out.println("sum= "+sum);
    }
}

运行结果为：

4.do-while语句

do-while语句它的循环体至少先执行一次，因为它的条件表达式在循环的结尾。

格式：

do
{
  执行语句
  .......
}while(循环条件)

do-while语句具体流程图就不写了，可以参照我专栏C语言里写的流程图：点击直接查看

案例：打印1-6的自然数（结合着while语句进行学习）

public class lesson2 {
    public static void main(String[] args) {
        int i = 1;
        do {
            System.out.println("i= "+i);
            i++;
        }while(i<=6);
    }
}

运行结果：

5.for语句

for循环执行过程：
1.初始化表达式确定初始条件
2.进入循环条件，判断初始化条件是否成立，如果成立，则执行{ }内的语句，不成立就结束。
3.然后执行操作表达式，将条件改变。
4.条件改变后，再执行循环条件，判断条件改变后是否成立，重复第二步，就这样依次循环，直到条件成立。

for语句具体流程图就不写了，可以参照我专栏C语言里写的流程图：点击直接查看

案例：求1-6的数的和。

public class lesson2 {
    public static void main(String[] args) {
        int sum=0;
        for(int i=1;i<=6;i++)
        {
            sum+=i;
        }
        System.out.println("sum= "+sum);
    }
}

运行结果如下：

6.break语句

JAVA中break语句有三种作用：
第一：在switch语句中，它被用来终止一个语句块。
第二：它能被用来退出一个循环。
第三：break后面加语句标签实现跳转。

通过一个案例来分析，需求是：假设班级有30名学生，查找编号为10的学生，找到循环后结束。

public class lesson2 {
    public static void main(String[] args) {
        for(int x=1;x<=30;x++)
        {
            if (x==10)
            {
                System.out.println("找到了编号为:"+x+"的学生");
            }
        }
    }
}

运行结果为：

7.continue语句

有时需要强迫一次循环提前结束从而进入下一次循环。
案例；

public class lesson2 {
    public static void main(String[] args) {
        int[] array = { 1, 2, 3, 4, 5 };
        int total = 0;
        for (int i : array) {
            if (i % 2 == 0)
                continue;
            total += i;
        }
        System.out.println(total);
    }
}

运行结果：

8.return语句

return语句用来明确的从一个方法返回，使程序控制权返回到调用它的方法，因此return语句也属于跳转语句。
案例：

public class lesson2 {
    public static void main(String[] args) {
        for (int i = 1;i <= 10 ;i++ ) {
            if (i == 4) {
                return;
            }
        }

        System.out.println("循环结束了");
    }

}

运行结果：

return后面的语句就不在执行了。

后续

后面的内容等我复习完后再做总结，哪里有错的地方请纠正，多多支持。