Java语言基础

java

计算机高级语言都有，只不过是表现形式不一样

掌握两点：1表现形式什么样 ，2这个东西什么时候用

• 关键字
• 标识符
• 注释
• 常量和变量
• 运算符
• 语句
• 函数
• 数组

关键字

只不过就是一些单词，但是被Java赋予了特殊的含义

class Demo
{
    public static void main(String[] args){
        System.out.println("Hello World!");
    }
}

其中，class，public，static，void这些都是关键字,关键字都是小写（规范）

标识符

用于标识某些东西的符号

规则如下：

• 在程序中自定义的一些名称
• 由26个英文字母大小写，数字0-9，符号$和_组成
• 数字不可以开头
• 不可以使用关键字
• Java严格区分大小写

规范如下：

• 类名接口名：所有单词首字母大写
• 方法名变量名：第一个单词首字母小写，其余单词首字母大写(驼峰式)
• 常量名：所有单词大写，单词之间用下划线_连接
• 包名： 所有单词小写

注：在起名时，为了提高阅读性，要尽量有意义。

注释

注解说明

• 用于注解说明解释程序的文字就是注释
• 提高代码的阅读性

单行注释：//注释文字

多行注释：/*注释文字*/

文档注释：/**注释文字*/

文档注释可被javadoc.exe程序提取

注意：单行可嵌套单行，单行可嵌套多行，多行可嵌套单行，多行不能嵌套多行

注释不走字节码(.class)！！！只存在于源代码(.java)

用处：不仅仅注解，也可调试程序

常量

表示不能改变的数值，就是生活中常见的数据

Java中的常亮分类

• 整数常量，所有整数
• 小数常量，所有小数
• 布尔型常量boolean，较为特殊，只有两个数值，true，false
• 字符常量，将一个数字、字母或者符号用单引号（''）标识
• 字符串常亮，将一个或多个字符用双引号（""）标识
• null常量，只有一个数值就是null

进制

只是一种计数方式

1周7天，1年12个月，1小时60分钟，十进制的12、15

• 二进制：0~1，满2进1
• 八进制：0~7，满8进1，用0开头表示
• 十六进制：0~9，A~F,满16进1，用0X开头表示

在计算机中，1个比特只能保存2种数据，8个比特能保存2^8种数据，所以**规定**1个字节（byte），由8个比特位（二进制位）组成。那么字节就是计算机中的最小数据单元。

10010101则就表示一个数据，它主要是给计算机看的。为了方便人类使用，可以将它拆成若干组。

比如：

3个比特为一组 则就是010-010-101（不够补0），这就是八进制

4个比特为一组，则就是1001-0101，这就是十六进制

十进制与二进制转换

• 十进制中：214 = 4×10^0 + 1×10^1 + 2×10^2
• 二进制中：10010101=1×2^0 + 0×2^1 + 1×2^3 + 0×2^4 + 1×2^5 + 0×2^6 + 0×2^7 + 1×2^8 = 149

那么149的二进制如何计算呢？

• 149%2=74-1
• 74%2=37-0
• 37%2=18-1
• 18%2=9-0
• 9%2=4-1
• 4%2=2-0
• 2%2=1-0
• 1%2=0-1

所以二进制位从下到上余数的排列10010101

二进制与八进制

10010101 分三组为 010-010-101

换算如下：

• 第一组：010 -> 0×2^0 + 1×2^1 + 0×2^2 = 2
• 第二组：010 -> 0×2^0 + 1×2^1 + 0×2^2 = 2
• 第三组：101 -> 1×2^0 + 0×2^1 + 1×2^2 = 5

所以八进制为0225

该八进制的十进制为 0×8^3 + 2×8^2 + 2×8^1 + 5×8^0=0 + 128 + 16 + 5=149

二进制与十六进制

10010101分为两组 1001-0101

换算如下：

• 第一组：1001 -> 1×2^0 + 0×2^1 + 0×2^2 + 1*2^3 = 9
• 第二组：0101 -> 1×2^0 + 0×2^1 + 1×2^2 + 0*2^3 = 5

所以十六进制为0X95

变量

• 内存中的一个存储区域
• 该区域有自己的名称（变量名）和类型（数据类型）
• 该区域的数据可以在同一类型范围类不断变化

• 为什么要定义变量：用来不断地存放同一类型的常量，并可以重复使用
• 使用变量注意：变量的作用范围（一对{}中有效），初始化值，不能重复定义
• 定义变量的格式：数据类型 变量名=初始化值;
• 理解：变量就如同数学中的未知数

名字便于寻找，类型进行约束；一旦数据不确定，就定义变量

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

数据类型分两大类：基本数据类型，引用数据类型

基本数据类型：

• 数值型
  
  • 整数类型(byte,short,int,long)
  • 浮点类型(float,double)
• 字符型(char)
• 布尔型(boolean)

引用数据类型：

• 类(class)
• 接口(interface)
• 数组([])

注：整数默认int，小数默认double

• byte，占1个字节（-2^7 ~ 2^7-1 -> -128 ~ 127）
• short，占2个字节(-2^15 ~ 2^15-1 -> -32768 ~ 32767 )
• int，占4个字节（-2^31 ~ 2^31-1）
• long，占8个字节（-2^63 ~ 2^63-1）
• float，单精度，占4个字节
• double，双精度，占8个字节
• char，取值范围0-65535，占2个字节（可以放中文，一个汉字2个字节）
• boolean，内存不确定

自动类型转换&强制类型转换

• 自动类型转换 也叫隐式转换转换
• 强制类型转换 也叫显示类型转换

• 所有byte，short，char的值将被提升为int型
• 如果有一个操作数是long，结果就是long型
• 如果有一个操作数是float，结果就是float型
• 如果一个操作数是double，结果就是double型

问题：

byte b=10;
byte b1=3;
byte b2=7;
b=b1+b2;

为什么报错？

因为，10默认是int型，在赋值给b的时候，被“阉割了”，b1,b2也一样，但是到了b=b1+b2时，由于等式右边是变量，b无法确定其值，导致可能丢失精度的问题

int x=10;
int x1=3;
int x2=7;
x=x1+x2;

为什么不报错？

因为3,7,10本身就默认int型，不会被“阉割”，运行到x=x1+x2时，结果还是int型。就算超出范围，也会输出。

==========作业==========

1.复习并完成全部课堂演示代码，整理笔记
2.将十进制数151分别用八进制、十六进制、五进制表示。
3.将人名字符的HEX编码输出，手工转换为二进制就，并验证结果。
4.尝试实现《函数计算器》和《等额本息还款计算》

运算符

算数运算符

加，减，乘，除，模运算，连接符

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

int x=6370;
x=x/1000*1000;//舍弃小数点
5%2=2余1

任何数与字符串相加结果是字符串

自增++

在原有数据基础上+1，在赋给原有数据

int a=2，b；
b=a++;
int i=3;
i=i++；

赋值运算符

int a=b=c=4;
+=,-=,*=,/=,%=

short s=3;
s+=4;//自动转换
s=s+4;//没有转换，除非强制

比较运算符

>,<,>=,<=,==,!=

运算结果要么true，要么false

逻辑运算符

&&，||，！

三元运算符

语句：布尔表达式?表达式1:表达式2
true时为表达式1
false时为表达式2

boolean isBoy=true;
int level=isBoy?2:3;//2

语句

判断结构

   语法: if(布尔表达式){
          //语句块..
        }else{
          //语句块
        }
   嵌套: if(布尔表达式){
          //...
        }else if(布尔表达式){
          //...
        }else if(布尔表达式){
          //...
        }else{
          //...
        }

——————练习：分页计算

选择结构

   语法: switch: 开关, case: 情况下
     switch(整数表达式){ 
       case 整数常量1:
         //语句序列
         break;
       case 整数常量2:
         //语句序列
         break;
       default: 
         //语句序列
     }

- switch条件：只能是整数表达式(byte short int char)，不能处理long或者其他类型
- case：只能是整数常量，不能使用变量或表达式
- break：跳出结构。

if和switch的区别：
if：
对具体的值进行判断
对区间判断
对运算结果是boolean类型的表达式进行判断
switch：
对具体的值进行判断
值的个数通常是固定的

所以，对于几个固定的值判断，建议使用switch语句，因为switch语句会将具体的答案都加载进内存，效率相对高一点。

——————练习：输入成绩，打印评价

循环结构

while循环：一般用在循环次数不确定的情况下

语法:
while(布尔表达式){
  //循环体 语句序列
}

——————练习：打印菜单，根据菜单内容输入选项

for循环：一般用在循环次数确定的情况下，比如数据的遍历操作。

语法:
for(开始;结束;过程){
    //循环体 语句序列
}   

——————练习：99乘法表 ；100以内奇数的和

函数

• 函数就是定义在类中的具有特定功能的一段独立小程序
• 函数也成为方法(Method)

函数格式：

修饰符 返回值类型 函数名（参数类型 形式参数1，参数类型2，形式参数2，...）{
    执行语句；
    return 返回值；
}

- 返回值类型：函数运行后的结果的数据类型
- 参数类型：是形式参数的数据类型
- 形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数
- 实际参数：传递给形式参数的具体数值
- return：用于结束函数
- 返回值：该函数运算后的结果，该结果会返回给调用者

函数的特点

• 定义函数可以将功能代码进行封装
• 便于对该功能进行复用
• 函数只有被调用才会被执行
• 函数的出现提高了代码的复用性
• 对于函数没有返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以忽略不写
• 函数中只能调用函数，不可以在函数内部定义函数
• 定义函数时，函数的结果应该返还给调用者，交由调用者处理

函数的重载

在同一个类中，允许存在一个以上的同名函数，只要他们的参数个数或者参数类型不同即可

int add(int x,int y){}
int add(int x,int y,intz){}
double add(double x,double y){}

函数的功能一样，仅仅是参与运算的未知内容不同

在调用时，虚拟机通过参数列表的不同来区分同名函数

==========作业==========

1.复习并完成全部课堂演示代码，整理笔记
2.将练习代码封装进函数。
3.完成《函数计算器》和《等额本息还款计算》

数组

同一种类型数据的集合。其实数组就是一个容器

可以自动给数组中的元素从0开始编号，方便操作这些元素。

格式1：

元素类型[] 数组名=new 元素类型[长度];
int[] arr=new int[5];

格式2：

元素类型[] 数组名=new 元素类型[]{元素1,元素2,...};
int[] arr=new int[]{1,4,5,6,7};
int[] arr={1,2,3,4,5};

容器就是一个实体，它区别与普通变量，需要用new关键字创建，一旦确立，必须指定长度

内存划分

• 寄存器
• 本地方法区
• 方法区
• 栈内存
  
  • 存储的都是局部变量（方法中的变量，for里的i也是）
  • 而且变量所属的作用域一旦结束，该变量自动释放
• 堆内存
  
  • 存储的是数组和对象（其实数组就是对象），凡是new出来的都在堆中。
  • 特点：都有地址值，都有默认初始化值，垃圾回收机制

数组的遍历操作

for(int i=0;i<arr.length;i++){
    sop(arr[i]);
}
for(int i=arr.length-1;i>=0;i--){
    sop(arr[i]);
}

数组的扩容问题

1.Java数组对象的大小是固定的，数组对象是不能扩展的
2.利用数组复制的方法可以变通的实现数组扩展
3.Arrays.copyOf()可以简便的创建数组副本
4.创建数组副本的同时将数组长度增加就变通的实现了数组的扩展

——————练习：统计一个字符在字符串中出现的次数。

数组中的最值操作

/*
需求：寻找最大值和最小值
1.既然需要寻值，就需要遍历数组
2.需要寻找特殊的值，则需要一个变量来存储
3.这个特殊值的变量不能在循环中定义，否则将无法访问
4.开始寻值，先将数组中第一个数赋值给特殊值的变量
5.开始遍历数组，依次取出数组中的值和该变量的值比较
6.最终寻值结果就是符合条件的值
*/
class ArrayMaxMin 
{   
    public static void main(String[] args) 
    {
        int[] arr=new int[]{-1,-5,6,-8,9,-4,3,2,7};
        findMaxMin(arr);
        findMaxMin2(arr);
    }
    public static void findMaxMin(int[] res){
        int MAX=res[0];
        int MIN=res[0];
        for(int i=0;i<res.length;i++){
            if(res[i]>MAX) MAX=res[i];
            if(res[i]<MIN) MIN=res[i];
        }
        System.out.println("MAX="+MAX+",MIN="+MIN);
    }

    public static void findMaxMin2(int[] res){
        int max_Index=0;
        int min_Index=0;
        //如果i<res.length,则会出现res[9]
        for(int i=0;i<res.length-1;i++){
            if(res[i]>res[max_Index]) max_Index=i;
            if(res[i]<res[min_Index]) min_Index=i;
        } 
        System.out.println("MAX2="+res[max_Index]+",MIN2="+res[min_Index]);
    }
}

选择排序

    for(int i=0;i<arr.length-1;i++){

        for(int j=i+1;j<arr.length;j++){
            if(arr[i]>arr[j]){
                int temp=arr[i];
                arr[i]=arr[j];
                arr[j]=temp;
            }                   
        }
    }

冒泡排序

    for(int i=0;i<arr.length-1;i++){
        /*
            内循环-1：为了避免角标越界
            -i：外循环递增，内循环参数与比较的元素个数递减
        */
        for(int j=0;j<arr.length-1-i;j++){
            if(arr[j]>arr[j+1]){
                int temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }
    }

折半查找

public static int binarySearch(int[] arr,int key){
    int max,min,mid;
    min=0;
    max=arr.length-1;
    mid=(max+min)/2;

    while(arr[mid]!=key){
        if(key>arr[mid]){
            min=mid+1;
        }else if(key<arr[mid]){
            max=mid-1;
        }
        if(max<min){
            //插入一个数，取其位置
            return -1;
        }
        mid=(max+min)/2;
    }
    return mid;
}

二维数组

数组的每个元素也是数组

格式1：

int[][] arr=new int[3][2];

二维数组中有3个一维数组

每一个一维数组中有2个元素

格式2：

int[][] arr=new int[3][];

二维数组中有3个一维数组

每一个一维数组都是默认初始化null

arr[0]=new int[3];
arr[1]=new int[4];
arr[2]=new int[7];

方法的递归调用

java栈：是java进程启动时候在内存中开辟的存储空间，栈内存利用LIFO方式。Java所有局部变量都在栈中分配(压入)，方法的参数也是局部变量，局部变量在离开作用于时候回收，就是从栈中弹出。

Java方法调用使用栈实现，递归调用就是栈实现的

递归时候要按照递归深度分配全部临时变量，栈开销很大，性能不好，要注意不要超过栈的大小，并且一定要给出结束条件，否则会造成栈溢出错误。

特点：解决问题简练，但性能很差，一定要给出结束条件。

——————练习：n的阶乘

==========作业==========

1.复习并完成课堂演示代码，并整理笔记
2.统计每个字符在字符数组中的个数
3.统计一个字符在字符串中的所有位置
4.将字符串中奇数位的数字相加
5.将一个整数翻转并输出，如4253，输出为3524
6.红球蓝球彩票问题