java基础入门

hello world

public class hello {
    //main方法是程序的入口，格式固定
    public static void main(String[] args) {
       System.out.println("hello world!");//输出到控制台
    }

注释

单行注释： //
多行注释： /* /
文档注释
格式:/*
@author
@version
注释内容可以被jdk提供的工具javadoc所解析，生成一套以网页文件形式体现的该程序的说明文档
*/
使用方法：终端 javadoc -d myhello -author -version 文件名.java
-d myhello:保存路径
找index.html

关键字：被java赋予了特殊含义，用作专门用途的字符串（所有字母为小写）

保留字：在现有的java中没有使用，在以后的版本中可能作为关键字使用，用自己命名的标识符时要避免使用这些保留字
goto\const

#标识符

标识符：自己起名的字符序列，尽量做到见名知意
规则：
1，由26个英文字母大小写、0-9，_或$组成
2，数字不可以开头
3，不可以使用关键字和保留字，但是能包含
4，严格区分大小写，长度无限制
5，标识符不能包含空格
java中命名规范：
包名：多单词组成，所有字母都小写
类名/接口名：多单词组成，所有单词首字母大写
变量名/方法名:多单词组成,第一个单词首字母小写，之后所有单词首字母大写
常量名：所有字母都大写，多单词时用下划线连接

#变量

变量：变量类型，变量名，储存的值
注意：
1，java中的变量必须先声明后使用
2，使用变量名来访问这块区域的数据
3，变量的作用域：定义所在的一对{}内
4，变量只有在其作用域内猜有效
5，同一个作用域内，不能定义重名的变量

public class luanma {
    public static void main(String[] args){
        int myAge=12;//变量的定义
        System.out.println(myAge);//变量的使用
        int myNumber;//变量的声明
        myNumber=1001;//变量的赋值
        System.out.println(myNumber);
    }
}

变量的分类（数据类型）：

1，整型变量：
变量通常声明为int型，除非不足以表示较大的数，猜使用long,声明long型常量后面必须加‘I’或者‘L’

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RJiXiyfX-1653015479286)(https://cdn.jsdelivr.net/gh/kaolaaa/kaola@main/img/202202242212050.png)]

public class luanma {
    public static void main(String[] args){
        //byte(字节，-128~127)short(2字节)int(4字节)long(8字节）
        byte b1=12;
        byte b2=-128;//b2=128,编译不通过
        System.out.println(b1);
        System.out.println(b1);
        long s1=1777799898222222L;//以L结尾
        System.out.println(s1);
    }
}

**浮点型变量：**float(4字节）double(8字节）
注意：声明float型常量，后面需要加‘f’或者’F‘

public class luanma {
    public static void main(String[] args){
        float f1=12.3F;//后面加F
        System.out.println(f1);
    }
}

3，字符型变量（1字符=2字节）

public class luanma {
    public static void main(String[] args){
        char c1='a';
        System.out.println(c1);
    }
}

4，boolean型变量
只能取两个值之间：ture/false，常在条件判断，循环结构中使用

public class luanma {
    public static void main(String[] args){
        boolean b1=true;
        System.out.println(b1);
    }
}

基本数据之间的运算（不包含boolean型）
1，自动类型提升/转换：容量小的和容量大的做运算时，结果自动提升为容量大的数据类型

public class luanma {
    public static void main(String[] args){
        byte a=2;
        int i=12;
        int  b= a+i;
        System.out.println(b);
    }
}
//byte、char、short（这三种做运算，结果都是int型）--int--long--float--double

2，强制类型转换：自动类型提升/转换的逆运算

public class luanma {
    public static void main(String[] args){
       double d1=12.3;
       int i=(int)d1;//强转符（）--强制转换，损失精度
       System.out.println(i);
    }
}

特殊情况
1，定义long时最后不加L，自动转换为int型，数字超过int范围则不可以
2，整型常量more类型为int型，浮点型常量默认类型为double型

字符串类型

String：不是基本数据类型，属于引用数据类型，使用方式与数据类型一致
注意：
1，一个字符串可以串接另一个字符串
2，声明String时需要使用一对“”
3，可以和8种基本数据类型做运算，且只能是连接运算+，结果仍然是String类型

public class luanma {
    public static void main(String[] args){
       String s1="hello world";
       System.out.println(s1);
       //运算
        int  number=2021;
        String name="lixuelian";
        String info=number+name;//连接运算
        System.out.println(info);
    }
}

算数运算符

1，除法

public class luanma {
    public static void main(String[] args){
            int num1=12;
            int num2=5;
            int result=num1/num2;
            System.out.println(result);//2.0
            double result2=num1/(num2+0.0);
            System.out.println(result2);//2.4
    }
}

2，取余运算
结果符号与被模数的符号相同
在开发中经常使用%来判断是否被除尽的情况

public class luanma {
    public static void main(String[] args){
            int n1=12;
            int m1=5;
            System.out.println(n1%m1);//2

            int n2=-12;
            int m2=-5;
            System.out.println(n2%m2);//-2

            int n3=12;
            int m3=-5;
            System.out.println(n3%m3);//2

            int n4=-12;
            int m4=5;
            System.out.println(n4%m4);//-2
    }
}

3，前/后++ 前/后–
前：先自增1，再运算
后：先运算，后自增1
自增自减不会改变数据类型

public class luanma {
    public static void main(String[] args){
            int n1=12;
            int n2=n1++;
            System.out.println(n2);//12
            int m1=12;
            int m2=++m1;
            System.out.println(m2);//13
    }
}

4,赋值运算符=
当“=”两侧的数据类型不一样时，可以使用字典类型转换或者强制类型转换云泽进行处理
扩展赋值运算符： +=，-=，*=，/=，%=

public class luanma {
    public static void main(String[] args){
            int i=10;
            i+=2;
            System.out.println(i);//12
    }
}

5,比较运算符
== != < > >= <= intanceof
比较运算符的结果都是boolean型，true/false
比较运算符"=="不能误写为“=”

public class luanma {
    public static void main(String[] args){
        //区分好==和=的区别
      int i=10;
      int j=20;
      System.out.println(i==j);//false
      System.out.println(i=j);//20,将j赋值给i
    }
}

6，逻辑运算符
&逻辑与 &&短路与
|逻辑或 ||短路或
！逻辑非 ^逻辑异或

public class luanma {
    public static void main(String[] args){
     //区分&与&&
        //相同点：&与&的运算结果相同，当符号左边是true时，二者会执行符号右边的运算
        //不同点：当符号左边是false时，&会继续执行右边的运算，&&不再执行符号右边的运算
        boolean b1=false;
        int num1=10;
        if(b1&(num1++>0)){
            System.out.println("我现在在北京");
        }
        else{
            System.out.println("我现在在南京");
        }
       System.out.println(num1);

        boolean b2=false;
        int num2=10;
        if(b2&&(num2++>0)){
            System.out.println("我现在在北京");
        }
        else{
            System.out.println("我现在在南京");
        }
        System.out.println(num2);
        /*  我现在在南京
            11
            我现在在南京
            10
            */
    }
}

7，位运算符:直接对整数二进制进行的运算，
每向左移一位，相当于*2
每向右移一位，相当于/2

public class luanma {
    public static void main(String[] args){
/*
<<:左移             3<<2=12    3*2*2=12
>>：右移            3>>1=1     3/2=1
>>>：无符号右移      3>>>1=1    3/2=1
&：与运算           6&3=2
|：或运算           6|3=7
^：亦或运算         6^3=5
~：取反运算         ~6=-7*/
        int m=12;
        int n=5;
        System.out.println(m&n);//4
        System.out.println(m|n);//13
        System.out.println(m^n);//9
    }
}

8，三元运算符
结构：（条件表达式）？表达式1：表达式2；
如果条件表达式为true执行表达式1，否则执行表达式2，表达式1和2的要求是一致的。
凡是可以使用三元运算符的地方，都可以使用if…else…结构，反之不成立。

public class luanma {
    public static void main(String[] args){
    int m=12;
    int n=13;
    int max=(m>n)?m:n;//如果是真，把m赋给max;如果是假，把n赋给max.
    System.out.println(max);//13
   }
}

Scanner

Scanner：如何从键盘获取不同类型变量
具体步骤:
1:导包–import java.util.Scanner
2:Scanner的实例化 Scanner scan=new Scanner(System.in); 加粗部分可以自己命名
3:调用scanner类的相关方法，获取指定类型的变量 int num=scan.nextInt();

import java.util.Scanner;
public class luanma {
    public static void main(String[] args){
        Scanner scan=new Scanner(System.in);
        int age=scan.nextInt();//int型
        System.out.println(age);

        String name=scan.next();//字符串型，与其他类型不一样
        System.out.println(name);

        double weight=scan.nextDouble();
        System.out.println(weight);//double型
    }
}

循环结构

基本流程控制：顺序结构，分支结构，循环结构
顺序结构：从上到下，逐行执行
分支结构：if…else… switch-case
循环结构: while do…while for重复性地执行某段代码

1，for循环
循环结构的四要素：初始化条件 、循环条件（boolean类型）、 循环体、迭代条件

public class luanma {
    public static void main(String[] args) {
        //用for循环---输出5个hello world
        for(int i=1;i<=5;i++){
            System.out.println("hello world");
        }
    }
}

public class luanma {
    public static void main(String[] args) {
        //使用for循环---遍历100以内的偶数
        for(int i=1;i<=100;i++){
            if(i%2==0) {
                System.out.println(i);
            }
        }
    }
}

2，while循环
说明：小心不要丢了迭代条件，一旦丢了，就可能导致死循环
for和while循环是可以相互转换的

public class luanma {
    public static void main(String[] args) {
        //用while循环---遍历100以内的偶数
        int i=0;
        while(i<=100){
            if(i%2==0){
                System.out.println(i);
            }
            i++;
        }
    }
}

3，do-while循环
特点：至少执行一次循环体
开发中使用for和while比较多

public class luanma {
    public static void main(String[] args) {
        //用do while循环---遍历100以内的偶数
        int i=0;
        do{
            if(i%2==0){
             System.out.println(i);
            }
            i++;
        }
      while(i<=100);
    }
}

4,嵌套循环
内层循环遍历一遍，只相当于外层循环体执行了一次
假设外层循环需要执行m次，内层循环需要执行n次，此时内层循环体执行了m*n次

public class luanma {
    public static void main(String[] args) {
 //嵌套循环，外层循环控制行数，内层循环控制列数
        for(int i=1;i<=6;i++){
            for(int j=1;j<7-i;j++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}
/*
*****
****
***
**
*
*/

数组

数组：是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名
数组特点：
1，数组是有序排列
2，创建数组对象会在内存中开辟一整块连续空间
3，数组长度一旦确定，就不能修改
4，数组是引用数据类型变量，数组的元素既可以是基本数据类型，也可以是引用数据类型
数组分类：
按照维数：一维数组，二维数组…
按照元素的类型：基本数据类型元素的数组、引用数据类型元素的数组

一维数组的使用
1，一维数组的申明和初始化：初始化完成，长度确定
2，如何调用数组指定位置的元素
3，如何获取数组的长度
4，如何遍历数组
5，数组元素的默认初始化值
6，数组的内存解析

public class luanma {
    public static void main(String[] args) {
        //1.一维数组的申明和初始化
        int[] num;
        num=new int[]{1001,1002,1003,1004};//静态初始化：初始化和赋值同时进行
        String[] name= new String[4];//动态初始化：初始化和赋值分进行
        //2,如何调用数组指定位置的元素
        name[0]="A";
        name[1]="B";
        //3，如何获取数组的长度 属性：length
        System.out.println(name.length);
        //4，如何遍历数组
        for (int i=0;i<=4;i++){
            System.out.println(name[i]);
        }
    }
}

public class luanma {
    public static void main(String[] args) {
        //5，数组元素的默认初始化值
        int[] arr=new int [4];
        for (int i=0;i<arr.length;i++){
            System.out.println(arr[i]);//0 0 0 0
            //整型：默认初始化值 0
            //浮点型：默认初始化值 0.0
            //char型：默认初始化值 0或‘\u0000'而不是’0‘
            //boolean型：默认初始化值false
        }
    }
}

二维数组的使用
理解：可以看做是一维数组arr1又作为另一个一维数组arr2的元素而存在
规定：二维数组分为外层数组元素，内层数组元素
int[] arr=new int[4][3];
外层元素：arr[0] arr[1] arr[2]
内层元素：arr[0][1] arr[2][1]

数据结构：
1，数据与数据之间的逻辑关系：集合、一对一、一对多、多对多
2，数据的村塾结构：
线性表（一对一）：顺序表（数组）、链表、栈、队列
数行结构（一对多）：二叉树
图形结构（多对多）：
算法：排序算法、搜索算法

public class luanma {
    public static void main(String[] args) {
        //1，二维数组的申明和初始化
        int [][] arr1=new int[][]{{1,2,3,4},{5,6,7,8,},{8,9,0}};//静态
        String[][]arr2=new String[3][2];//动态
        String[][]arr3=new String[3][0];
        //2，如何调用数组指定位置的元素
        System.out.println(arr1[0][0]);//1
        //3，如何获取数组的长度
        System.out.println(arr1.length);//3
        System.out.println(arr1[0].length);//4
        //4，如何遍历数组
        for(int i=0;i< arr1.length;i++){
            for(int j=0;j< arr1[i].length;j++){
                System.out.printf(arr1[i][j]+" ");
            }
            System.out.println();
        }
    }
}

public class luanma {
    public static void main(String[] args) {
        //5，二维数组元素的默认初始化值
        //外层元素的初始化值：地址值
        //内层元素的初始化值：与一维数组初始化情况相同
        int arr[][]=new int[3][4];
        System.out.println(arr[0]);//[I@776ec8df    地址值
        System.out.println(arr[0][0]);//0
    }
}

练习题一：打印杨辉三角
算法步骤
1，申明并初始化二维数组（动态）
2，给数组的元素赋值：给首末元素赋值 给每行的非首末元素赋值
3，遍历数组

public class luanma {
    public static void main(String[] args) {
     int[][] Y=new int[10][];
     //赋值
     for(int i=0;i<Y.length;i++){
         Y[i]=new int[i+1];
         //给首末元素赋值
         Y[i][0]=1;
         Y[i][i]=1;
         //给每行的非首末元素赋值
         if(i>1){
             for(int j=1;j<Y[i].length-1;j++){
                 Y[i][j]=Y[i-1][j-1]+Y[i-1][j];
             }
         }
     }
     //遍历数组
     for(int i=0;i< Y.length;i++){
         for(int j=0;j<Y[i].length;j++){
             System.out.print(Y[i][j]+" ");
         }
         System.out.println();
     }

    }
}

数组的复制和元素反转

public class luanma {
    public static void main(String[] args) {
     String[] arr=new String[]{"AA","BB","CC","DD","EE","FF"};
     //数组的复制
        String[] arr1=new String[arr.length];
        for (int i=0;i< arr.length;i++){
            arr1[i]=arr[i];
        }
    //数组的反转
        for(int i=0;i<arr1.length/2;i++){
            String temp=arr[i];
            arr[i]=arr[arr.length-i-1];
            arr[arr.length-i-1]=temp;
        }
        //遍历输出
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+"\t");//FF EE DD CC BB AA
        }
    }
}

数组的查找

public class luanma {
    public static void main(String[] args) {
     String[] arr=new String[]{"AA","BB","CC","DD","EE","FF"};
        //遍历输出
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+"\t");//FF EE DD CC BB AA
        }
        //线性查找
        String dest ="BB";
        dest="yy";
        boolean goal=true;
        for(int i=0;i<arr.length;i++){
            if(dest.equals(arr[i])){
                System.out.print("\n找到了！位置为"+i);
                goal=false;
                break;
            }
        }
       if(goal){
           System.out.print("\n没有找到！");
       }
    //二分法查找：所要查找的数组必须有序
        int arr2[]=new int[]{1,2,3,4,5,6,7,8,9,10};
       int dest1=1;
       int head=0;//初始的首索引
        int end=arr.length-1;//初始的末索引
        boolean goal1=true;
        while(head<=end){
        int middle=(head+end/2);
        if(dest1==middle){
                System.out.print("\n找到了，位置为"+middle);
                goal1=false;
                break;
            }
            
            else if(arr2[middle]>dest1){
                end=middle-1;
            }
           
            else {
                head=middle+1;
            }
        }
        if(goal1){
            System.out.print("\n没有找到！！");
        }

    }
}

排序算法
十大内部排序：选择排序、交换排序、插入排序、归并排序、桶式排序、基数排序

public class luanma {
    public static void main(String[] args) {
    //数组的冒泡排序
        int[] arr=new int[]{12,4,3,56,7,89,0};
        for(int i=0;i<arr.length-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;
            }
            }
        }
        for(int m=0;m<arr.length;m++){
            System.out.print(arr[m]+"\t");//0	3	4	7	12	56	89	
        }
        }
    }