JAVA基础语法和实战

基础语法

1.博客

大家都知道，博客很作用，生活的博主会在博客上记录自己的生活。旅游博主会记录自己的旅途等。而CSDN博客可以为我们提供完善的属于程序员的交流平台。咱们可以把我们所学的内容通过自己的理解写出来。这样既加深了印象，有可以锻炼写作表达能力。我就是从秦疆那学习Java开始写博客的。亦然，很多知识都可以从博客上去知道。大多数的程序员都在CSDN博客上发表自己的文章。所以和我一样学编程的小伙伴可以开始入坑CSDN博客了哦。

2.makerdowm语法

makerdowm语法在CSDN中也有官方的帮助文档。当然，我也自己总结了一下常用的编辑功能。在我的博客上的makerdown如何使用。

3. 冯▪诺依曼体系结构

计算机教父之称的冯▪诺依曼提出的计算机体系结构。其结构是存储程序原理的理论。

4.注释

同样的，注释作为编程开发的一个工具方法，亦是很重要的。程序要精简易懂，没有注释的长程序，别人很难看懂，难以高效开发。

5.数据基本类型及引用类型（primitive type、reference type）

整数类型：byte short int char long
小数类型：float double
字符：char
字符串：String
布尔值：boolean （只有两个有效值true、false）
引用类型：类、接口、数组

6.类型转换

强制转换：高容量转到低容量

package com.f.www.base;

public class leixingzhuanhuan {
    public static void main(String[] args) {
        int i=128;
        byte i2= (byte) 128;
        System.out.println(i);
        System.out.println(i2);
        //强制转换（类型）变量名  高-低
        //自动转换 ，低-高
        /**1.不能对布尔值进行转换
         * 2.不能把对象转换成不相干的类型
         * 3。转换时可能存在内存溢出，或精度问题
         * 4.把高容量转换成低容量时，强制转换
         */
        System.out.println("-----------------------");
        System.out.println((int)23.5);
        System.out.println((int)-23.98f);//小数点后面舍去了 精度问题。
        System.out.println("------------------------");
        //溢出问题
        int money=10_0000_0000;
        int years =20;
        int total=money*years;
        long total2=money*years;
        int total3= (int) (money*((long)years));//转换之前默认时int类型，
        System.out.println(total);
        System.out.println(total2);
        System.out.println(total3);
        System.out.println("---------------------------");
        long total4=(int)money*(long)years;//计算之前先转换一个变量类型
        System.out.println(total4);

    }
}

7.变量

局部变量：必须声明和初始化值
实例变量：从属于对象，如不初始化则引用其类型默认值
（基本类型默认值为0，布尔值为false，其余类型皆为null）
常量（constant）：初始化后不能改变其值

package com.f.www.base;

public class bl {
    //类变量，从属于类
    static double salaey=3000;
    //实例变量从属于对象，如不初始化,输出这个类型的默认值0，0.0；
    //布尔值的默认值是false
    //其他类型都是null
    String name;
    int age;
    final int A=1;//定义了一个常量名为A，值为1的常量（常量名一般用大写字母）
    public static void main(String[] args) {
        //局部变量,必须声明和初始化
        int i=10;
        System.out.println(i);
        bl bl=new bl();
        System.out.println(new bl().age);//new 类 类名（）.变量名
        System.out.println(new bl().name);
        System.out.println(bl.age);
        System.out.println(bl.name);

    }
}

8. 运算符

自增运算符++
自减运算符–
自增自减运算符在前：先运算再赋值。
自增自减运算符在后：先赋值再运算
幂运算：math工具
三元运算：x?y:z

package com.f.www.base.Operator;

public class Demo01 {
    public static void main(String[] args) {
        //二元运算
        int a=10;
        int b=20;
        int c=30;
        int d=40;
        System.out.println(a+b);
        System.out.println(a-c);
        System.out.println(a*b);
        System.out.println(a/(double)c);
        System.out.println("-------------------------");
        long a1=123333;
        int a2=122;
        short a3=10;
        byte a4=1;
        System.out.println((double)a3+a4);
        System.out.println(a>b);
        System.out.println(d%a);//模运算
        System.out.println("-------------------------");
        int x1=3;
        System.out.println(x1);
        int x2=x1++;//先赋值再自增
        int x3=++x1;//先自增在赋值
       // System.out.println(x1);
        System.out.println(x2);
        System.out.println(x3);
        //幂运算
        double pow = Math.pow(2, 3);
        System.out.println(pow);
        //逻辑运算符
        boolean c1=true;
        boolean c2=false;
        System.out.println("c1&&c2："+(c1&&c2));//逻辑与预算:全为真，结果为真
        System.out.println("c1||c2:"+(c1||c2));//逻辑或预算：一个为真，结果为真
        System.out.println("!(c1||c2:)"+!(c1||c2));//如果是真，则为假，反之。
        System.out.println("--------------------------");
        //位运算
        /*
        A=0011 1100
        B=0000 1111
        -----------
        A&B=0000 1100
        A|B=0011 1111
        A^B=0011 0011
        ~A=1100 0011
         */
        System.out.println("---------------");
        System.out.println(2<<3);
        System.out.println("---------------");
        int d1=0x08;
        int d2=0x16;
        System.out.println(d1|d2);
        //短路运算
        System.out.println("---------------");
        int c3=5;
        int c5=c3++;
        boolean c4=(c3<17)&&(c3++<7);
        System.out.println("c4:"+c4);
        System.out.println("c5:"+c5);
        System.out.println("----------------");
        System.out.println(c3);
        /*
        int a=10;
        int b=20;
        int c=30;
        int d=40;
         */
        a+=b;//a=a+b
        System.out.println(a);
        a-=b;//a=a-b
        System.out.println(a);
        //三元运算符
        //x?y:z 如果x==true 则结果为y，否则为z
        int score =50;
        String type=score<60?"不及格":"及格";
        System.out.println(type);
    }
}

9.包机制

公司官网倒置建包。

10.顺序结构、if选择结构、swich结构、while、do while结构、for、for增强结构

package Struct;

import java.util.Scanner;

public class StructDemo01 {
    public static void main(String[] args) {
        System.out.println("Hello 1");
        System.out.println("Hello 2");
        System.out.println("Hello 3");
        System.out.println("Hello 4");
        System.out.println("Hello 5");
        //顺序结构
        System.out.println("----------------");
        Scanner scanner=new Scanner(System.in);
        String s=scanner.nextLine();
        if (s.equals("Hello")){
            //equals  比较字符串是否一致
            System.out.println(s);
        }
        System.out.println("End");
        //if单选泽结构
        System.out.println("--------------");
        int score=scanner.nextInt();
        //score  成绩
        if (score>60) {

            System.out.println("成绩合格" + score);
        }
        else {
            System.out.println("成绩不合格" + score);
        }
        // if双选结构
        System.out.println("------------------");
        int score1=scanner.nextInt();
        if(score1>=90) {
            System.out.println("优");
        }else if (score1>=60&&score1<90){
            System.out.println("良");
        }else if (score1>=30&&score1<60){
            System.out.println("中");
        }else if (score1>=0&&score1<30){
            System.out.println("差");
        }else System.out.println("成绩不合法");
        //单行if else 可不带大括号
        //if 多选择结构
        System.out.println("------------------");
        scanner.close();
    }
}

package Struct;

public class switchDemo01 {
    public static void main(String[] args) {
        String grade="a";
        switch (grade){
            case "a":
                System.out.println("还有诗和远方的田野");
                break;
            case"b":
                System.out.println("良好");
                break;
            case "c":
                System.out.println("及格");
                break;
            case "d":
                System.out.println("再接再厉");
                break;
            case "e":
                System.out.println("挂科");
                break;
            default:
                System.out.println("未知等级");
                //case具有穿透性，所以用break截止，swich 匹配一个具体值
        }
    }
}

package Struct;

public class DoWhileDome01 {
    public static void main(String[] args) {
        int a=0;
        int sum=0;
       //while
        while(a<0){
            System.out.println(a);
        }
        //先执行判断是否为真再执行顺序操作
        //do while
        System.out.println("-----------");

        do {
            a++;
            sum=sum+a;
        }
        while (a<100);
        System.out.println(sum);
        //do while先执行一次do 再执行顺序判断。
    }
}

package Struct;

public class ForDemo01 {
    public static void main(String[] args) {
        int oddsum=0;
        int evensum=0;
        //计算100以内的奇数和与偶数和
        for (int i = 0; i < 100; i++) {//初始化条件  条件判断  迭代
            if (i%2!=0) {
                oddsum += i;//循环体
            }else
            {
                evensum+=i;//循环体
            }
        }
        System.out.println("奇数和："+oddsum);
        System.out.println("偶数和："+evensum);
        System.out.println("-----------------");
        //计算1000以内的可以被5整除的数，并每行输出3个。
        for (int i = 0; i <=1000; i++) {
            if (i%5==0) {
                System.out.print(i+"\t");
            }
            if(i%(5*3)==0) {
                System.out.print("\n");
            }
            //System.out.println();
            //println 自动换行
        }
    }
}

package Struct;
public class ForLianxi2 {
    public static void main(String[] args) {
        for (int j = 1; j < 10; j++) {
            for (int i = 1; i <= j; i++) {
                System.out.print(i + "*" + j + "=" + (j * i) + "\t");
            }
            System.out.print("\n");
        }
        System.out.println("--------------");
        //增强for
        int[] number = {1, 2, 3, 4, 5};
        for (int x : number) {
            System.out.print(x+"\t");
        }
        System.out.println();
        System.out.println("---------------");
        for (int i = 1; i <=100; i++) {
            if (i % 5 == 0) {
                System.out.println("中止位置");
                continue;
            }
            System.out.print(i+"\t");
            //continue 终止本次循环不会退出循环。
        }
        System.out.println("------------");
       outer://外层循环添加标签
        for (int i = 101; i < 150; i++) {
            //设置outer标签判断条件
            for (int j = 2; j < i; j++) {
                if (i % j == 0) {
                    continue outer;
                }
            }
            System.out.print(i + " ");
        }
        System.out.println();
        System.out.println("-------------");
        //打印三角形实战
        for (int i = 1; i <= 5; i++) {
            for (int j = 5; j >= i; j--)
                System.out.print(" *");
            for (int j = 1; j <= i; j++)
                System.out.print(" &");
            for (int j = 1; j < i; j++)
                System.out.print(" &");
            for (int j = 5; j >= i; j--)
                System.out.print(" *");
            System.out.println("");
        }
    }
}

11.Scanner类

Scanner类是从键盘获取数据

package Scannerxi;
import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        // 创建一个扫描器对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入：");
        //判断用户有没有输入字符串
        if (scanner.hasNext()){
            String str= scanner.next();
            System.out.println("内容输出为:"+str);
        }
        scanner.close();
    }
}

package Scannerxi;

import java.util.Scanner;

public class Demo02 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入：");
        scanner.hasNextLine();
        if (scanner.hasNextLine()){
        String cc =scanner.nextLine();
        System.out.println( "内容输出为:"+cc);

    }
        scanner.close();
     }

}

package Scannerxi;

import java.util.Scanner;

public class Demo03 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        //从键盘接收数据
        int a=0;
        float b=0.0f;
        System.out.println("请输入数据");
        if (scanner.hasNextInt())
        {
            a = scanner.nextInt();
            System.out.println("整数数据：" + a);
        }
         else{
            System.out.println("输入的不是整数数据:" );
        }
        System.out.println("请输入小数：");
        if(scanner.hasNextFloat()){
            b=scanner.nextFloat();
            System.out.println( "小数数据："+b);
        }
        else{
            System.out.println("输入的不是小数数据：");
        scanner.close();
            }
    }
}

package Scannerxi;

import java.util.Scanner;

public class Demo04 {
    public static void main(String[] args) {
        //输入多个数字，并求其总和与平均数；每一个数字输入完成后用回车确认，通过非数字结束输入并输出结果
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入数据：");
        double sum=0;
        //和
        int a=0;
        //计算输入了多少个数字
        while(scanner.hasNextDouble()) {
            double x = scanner.nextDouble();
            a = a + 1;
            sum = sum + x;
            System.out.println(a+"和为"+sum);
            System.out.println(a+"平均值为"+(sum/a));
        }
        scanner.close();
    }
}

12.break\continue\retrun的区别

break：常用于终止退出循环
continue：用于中止循坏，不退出循环
retrun：终止方法

13.方法定义和调用及重载

   修饰词 返回值类型 方法名（...）{
   
    方法体....
    
    return 返回值
    }

package Array;
//类
public class fangfa {
    //main 方法（主程序）
    public static void main(String[] args) {
        System.out.println(new fangfa().max(1,2));//方法调用
    }
    /*修饰词 返回值类型 方法名（...）{
    方法体
    return 返回值
    }
     */
    public String sayHello(){
        return "hello world";
    }
    public void  /*空*/  hello(){
        return;
    }
    public int max(int a,int b){
        return a>b?a:b;//三元运算符
    }
    //静态方法
    public static void say(){
    }
    //非静态方法
    public void sayi(){
    }
}

重载就是在一个类中，有相同的函数名称，但形参不同的函数。
方法重载规则
1.方法名必须相同
2.参数列表必须不同（个数不同，或类型不同、或参数排列顺序不同）
3.方法的返回值可以相同也可以不同
4.仅仅返回类型不同不足以成为方法的重载

11.可变参数

package method;

public class keBiancanshu {
    public static void main(String[] args) {
        keBiancanshu keBiancanshu = new keBiancanshu();
        keBiancanshu.test(1);
        System.out.println("-----------");
        printMax(22,535,55,66);
        printMax(new double[]{1,5,6,7,33,66});

    }
    public void test(int...i){
        System.out.println(i[0]);

    }
    public static void printMax(double... number){//可变参数符号 ... 可以定义无限个参数
        if (number.length==0){
            System.out.println("N0 argument passed");
            return;
        }
        double result=number[0];
        for (int i = 1; i < number.length; i++) {
            if (number[i]>result){
                result =number[i];
            }
        }
        System.out.println("The max value is "+result);
    }

}

12.递归

递归头：什么时候不调用自身方法，如果没有递归头将陷入死循环
递归提：什么时候调用自己

package method;

public class DIgui {
    public static void main(String[] args) {
        System.out.println(f(6)
        );
    }

    public  static  int f(int n){
        if (n==1){
            return 1;
        }
        else{
            //3*f（n-）=3*f（2）
            return n*f(n-1);//阶乘
        }
    }
}

13.数组的声明和创建

package Array;

public class ArraySm {
    public static void main(String[] args) {
        int[]a;//声明一个数组
        a=new int[5];//创建一个数组
        a[0]=1;//给数组元素赋值
        a[1]=2;//给数组元素赋值
        a[2]=3;//给数组元素赋值
        a[3]=4;//给数组元素赋值
        a[4]=5;//给数组元素赋值
    }
}

14.内存分析

1.堆：存放new 的对象和数组，可以被所有的线程共享，不会存放别的对象引用
2.栈：存放基本变量类型（包含基本类型的具体值），引用对象的变量（会存放引用在堆里的具体地址）
3.方法区：可以被所有的线程共享，包含了所有的clss和static变量

16.数组使用

package Array;

public class ArrayDemo01 {
    public static void main(String[] args) {
        int[] a = {1, 2, 3, 4, 5};
        //遍历数组 for each
        for (int i : a) {//for(int 数组元素：数组名）
            System.out.println(i);
        }
        System.out.println("----------------");
        //打印所有元素
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
        System.out.println("--------------");
        //计算所有元素的和
        double ax = 0;
        for (int i = 0; i < a.length; i++) {

            ax += a[i];

        }
        System.out.println("ax和为:" + ax);
        System.out.println("---------------");
        //查找最大元素
          int max = 0;
        for (int i = 0; i < a.length; i++) {

            if (a[i] > max) {
                max = a[i];
            }
            System.out.println("max:" + max);
        }

        int[] b = new int[10]; //动态初始化
        b[0] = 1;
        b[9] = 11;
        //静态初始化
        int[] c = {1,2,3,4};
        // System.out.println();
        System.out.println("---------");
        //printa(a);
        System.out.println("\n---------");
        
        int[] reverse = reverse(a);
        printa(reverse(a));
    }

    //定义一个方法
    //打印一个数组 数组作为方法入参
    public static void printa(int[] a) {
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }
    //反转数组 数组作为返回值
    public static int[]reverse(int[] a){
        int[]result =new int[a.length];
        for (int i = 0,j= result.length-1; i < a.length; i++,j--) {
            result[j]=a[i];

        }
        return (result);
    }
}

17.多维数组

即二维数组可以看成是特殊的一维数组（数组的嵌套）

18.arrays类

1.数组的工具类：java.util.Arrays
2.Arrays类中的方法都是static修饰的静态方法，在使用时可以直接使用类名进行调用而没必要再使用对象来调用
3.常用方法
给数组赋值：通过fill方法
对数组排序：通过sort方法升序
比较数组：通过equals方法比较元素值是否相等
查找数组元素：通过binarySearch方法对排序好的数组进行二分查找法操作

19.冒泡排序

package Array;

import java.util.Arrays;

//冒泡排序
public class maopaopaixun {
    public static void main(String[] args) {
        //比较数组中，两个相邻元素，如果第一个数比第二个数大，就交换他们的位置
        //每比较一次，就会产生一个最大和最小的数
        //下一轮可减少一次排序
        //依次循环，直到结束
        int temp = 0;
        int[] a = {1, 33, 4, 42, 3, 23, 424, 55, 2, 55, 23, 452,};
        //外层循环 判断要走多少次
        for (int i = 0; i < a.length; i++) {
            //判断是否大小一致，不用比较
            boolean flag;
            flag = false;
            //内层循环 比较两个数，第一个数比第二个数大 就交换位置
            for (int j = 0; j < a.length - 1 - i; j++) {
                if (a[j + 1] > a[j]) {
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                    flag = true;
                }
            }
            if (flag == false) {
                break;
            }
        }
        System.out.println(Arrays.toString(a));
    }
}

20.稀疏数组

package Array;

public class xishushuzu {
    public static void main(String[] args) {
        //创建一个数组11*11 0-没有棋子 1-黑棋 2-白棋
        int [][]arrays1 =new int[11][11];
        arrays1[1][2]=1;
        arrays1[2][3]=2;
        //输出原始的数组
        System.out.println("输出原始的数组");
        for (int[] ints : arrays1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        //转换为稀疏数组
        int sum=0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (arrays1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数："+sum);
        //创建一个稀疏数组
        int[][]arrays2= new int[sum+1][3];
        arrays2[0][0]=11;
        arrays2[0][1]=11;
        arrays2[0][2]=sum;
        //遍历二维数组 将非零的值，存放稀疏数组中
        int count=0;
        for (int i = 0; i < arrays1.length; i++) {
            for (int j = 0; j < arrays1[i].length; j++) {
                if (arrays1[i][j] != 0) {
                    count++;
                    arrays2[count][0]=i;
                    arrays2[count][1]=i;
                    arrays2[count][2]=arrays1[i][j];
                }
            }
        }
        System.out.println("稀疏数组");
        for (int i = 0; i < arrays2.length; i++) {
            System.out.println(arrays2[i][0]+"\t"
                    +arrays2[i][1]+"\t"
                    +arrays2[i][2]);
        }
        System.out.println("----------");
        System.out.println("还原");
        //都取稀疏数组
        int[][]arrays3=new int[arrays2[0][0]][arrays2[0][1]];
        //给其中的元素还原值
        for (int i = 1; i < arrays2.length; i++) {
            arrays3[arrays2[i][0]][arrays2[i][1]]=arrays2[i][2];
        }
        //打印
        System.out.println("输出还原的数组");
        for (int[] ints : arrays3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}