java基础

一、概述

1.1 java版本

Java SE（标准版）
Java EE（企业版）
Java ME（微缩版）

1.2 java语言特点

面向对象(使用计算机模拟现实世界,解决现实题,贴近人类思维模式)
筒单(相对C、C+、C#,不易造成内存溢出、滅少代码量、代码可读性强)
跨平台(操作系统、服务器、数据库)

1.3 java运行机制

.java源程序——编译器——.class字节码——解析器——机械码——计算机

运行机制

Java语言编译过程

1.4 java环境搭建

JDK（java development kit）
开发环境，包含JRE+类库+开发工具包（编译器+调试工具）
JRE（java runtime environment）
运行环境，包含：JVM和解释器
JVM（java virtual machine）
不同的操作系统中，模拟相同的环境

二、语言基础

2.1 编码规范

编码规范.png

2.2 变量

2.2.1 变量的组成

数据类型、变量名、值

2.2.2 变量的定义

第一种声明方式——先声明后赋值
数据类型变量名;
Int age;//开辟整数変量空间
変量名=值
age=18;/将整数值赋给変量
第二种声明方式——声明并赋值
int age = 18；
第三种声明方式——多个同类型变量的声明并赋值
int x,y,z = 11,12,13;
注意:Java是强类型语言,変量的类型必须与数据的类型一致。

2.3 运算符

2.3.1赋值运算符

赋值运算符

2.3.2 算术运算符

算术运算符

2.3.3关系运算符

关系运算符

2.3.4 逻辑运算符

逻辑运算符

2.3.5位运算符

2.3.6 移位运算符

2.3.7 对象运算符

2.3.8 三目运算符

格式
布尔表达式?结果1:结果2 //布尔表达式为真，则结果1，布尔表达式为假，则结果2

public static void main(String[] args) {
    int age = 18;
    String age1=age == 17?"成年了":"未成年";
    System.out.println(age1);
    int x = 10;
    int y = 5;
    int z;
    z = (x > y) ? x : y;//三目运算符
        /*if (x>y){
            z = x;
        }else {
            z = y;
        }*/
    System.out.println("z = " + z);
    }
}

2.4 数据类型

数据类型

2.4.1 基本数据类型

基本数据类型.png

2.4.2 引用数据类型

数组
类
接口

2.5 数据类型转换

2.5.1 自动类型转换

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

2.5.2 强制类型转换

public class TypeConversion {
    public static void main(String[] args) {
        short s = 123;
        int i = s;        //目标类型大于源类型  自动类型转换 short ---> int
        System.out.println(i);

        double d = i;       //目标类型大于源类型  自动类型转换 int ---> double
        System.out.println(d);

        short num = 123;
        byte target = (byte) num;       //目标类型小于源类型  强制类型转换 short ---> byte
        System.out.println(target);

        double x = 12.34;
        int y = (int) x;            //目标类型小于源类型  强制类型转换 double ---> int
        System.out.println(y);

        short m = 258;
        byte n = (byte) m;      //目标类型小于源类型  强制类型转换 short ---> byte
        System.out.println(n);

        int a = -65;
        char b = (char) a;      //目标类型小于源类型  强制类型转换 int ---> char
        System.out.println(b);
    }
}

2.5.3 字符串转为Int类型

public class StringChangeToInt {
    public static void main(String[] args) {
        //方式一
        int num = Integer.parseInt("56544" );
        //方式二
        int num2=Integer.valueOf("123");
        System.out.println(num+"  "+num2);
    }
}

2.6 控制台录入

import java.uti1. Scanner
Scanner sc = new Scanner();
sc.nextint();//获得整数
sc.nextdoubl();//获得小数
sc.next();  //获得字符串
sc.next().charAt(0);//获得单个字符

三、流程控制

3.1 选择分支

3.1.1 if...else...语句

3.1.2 switch语句

import java.util.Scanner;

public class WeekdaySwitch{
    public static void main(String[] args){ 
        //一周计划
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入1-7的数字：");
        int weekDay = sc.nextInt();
        switch(weekDay){
            default:
                System.out.println("录入有误，请输入1~7之间的有效数字！");
                break;
            case 1:
                System.out.println("学习java");
                break;      
            case 2:
            case 5:
            case 6:
                System.out.println("玩游戏");
                break;      
            case 3:
                System.out.println("爬山");
                break;  
            case 4:
                System.out.println("上班");
                break;
            case 7:
                System.out.println("考试");
                break;          
        }   
        System.out.println("结束");       
    }
}

3.2 循环

3.2.1 do...while循环

// do ... while循环
    public static void sum2() {
        int i = 0 ;
        int sum = 0;
        do{
            sum = sum + i;
            i++;
        }while(i<101);
        System.out.println(sum);
    }

3.2.2 while循环

// while循环
    public static void sum1() {
        int i = 0 ;
        int sum = 0;
        while(i<101){
            sum = sum + i;
            i++;
        }
        System.out.println(sum);
    }

3.2.3 for循环

// for循环
    public static void sum(){
        int sum = 0;
        for(int i=1;i<101;i++) {
            if(i%2!=0) {
            sum = sum + i;
            }
        }
        System.out.println(sum);
    }

3.2.4 foreach 循环 (两个功能：1遍历数组 2 遍历集合）

public class ForEachCircular {
    public static void main(String[] args) {
        // foreach循环遍历数组
        String [] names = {"xiao","xian","hua","nian"};
        for(String name:names){
            System.out.print(name + "\t");
        }
        System.out.println();
        // foreach循环遍历集合
        ArrayList<String> ming = new ArrayList<String>();
        ming.add("xiao");
        ming.add("xian");
        ming.add("hua");
        ming.add("nian");
        for(String m:ming){
            System.out.print(m + "\t");
        }
    }
}

3.3 跳转

3.3.1 break语句 :跳出循环

3.3.2 continue语句：跳出本次循环

public class BreakAndContinue {
    public static void main(String[] args) {
        for (int i = 1; i < 6 ; i++) {
            if (i % 5 ==0){
                break;
            }
            System.out.println("当前循环次数：" + i);
        }
        System.out.println("<--------------------->");
        for (int i = 1; i < 7 ; i++) {
            if (i % 5 ==0){
                continue;
            }
            System.out.println("当前循环次数：" + i);
        }
    }
}

四、函数

4.1 函数的概念

什么是函数？

函数就是定义在类中的具有特定功能的一段独立代码（函数==方法）

函数的优点

减少代码冗余。
提高复用性。
提高可读性。
提高可维护性
方便分工合作。

4.2 函数的定义

修饰符 返回值类型 函数名（[参数类型1 参数名1,参数类型2 参数名2 ....]）{
    代码块.......
    return  返回值；    //返回值的类型必须与返回值类型一致
}

4.3 函数的参数

形参：等同于局部变量
实参：

定义语法：
public static void 函数名称(形式参数){
      // 函数主体
}
调用语法
 函数名称(实际参数);

4.4 函数的返回值与返回值类型

定义语法
public static 返回值类型 函数名称(形式参数列表){
        // 函数主体
    return value; // 返回值
}
调用语法
变量 = 函数名称();   // 变量类型与返回值类型一致

4.5 return关键字

用途
（1）返回方法指定类型的值（前提是方法的返回值类型不是void）。
（2）方法的结束，它会导致当前的方法退出。
使用形式
（1）方法有返回值类型，格式：
return 返回值;
（2）方法没返回值类型，格式：
return;

4.6 函数的重载

在同一个类中，定义多个函数名相同、参数列表不同的函数。
调用时通过函数名和参数列表来确定一个函数,函数的重载和返回值类型无关。

public class Function_test {
public static void main(String[] args) {
    // TODO Auto-generated method stub
        int a = add(4,9);
        System.out.println(a);
        int b = add(4,9,4);
        System.out.println(b);
    }

// add函数，获取两个值的和
public static int add(int x,int y){
        int sum = x+y;
        return sum;
}

// add函数的重载 ,获取三个值的和
public static int add(int x,int y,int z){
    int sum = x+y+z;
    return sum;
  }
}

4.7 函数的递归

函数的内部调用自身的过程

// 斐波那契数列
public class RecursionFibonacci {
public static void main(String[] args) {
    // 1 1 2 3 5 8 13 21 34 55 89
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入fibonacci的项数：");
    int inpu = sc.nextInt();    
    int result = fibonacci(inpu);
    System.out.println(result);
}
public static int  fibonacci(int n){
    if (n == 0){
        return 0;
    }else if(n==1) {
        return 1;
    }
    return fibonacci(n-1)+fibonacci(n-2);
    }
}

递归输出文件目录名

public class RecursionFileName {   
public static void main(String[] args) {
        String path = "D:/";                   // 设定文件路径
        test(path);
    }
    private static void test(String path) {         // 输出文件目录函数
        File f = new File(path);                // 创建一个文件路径对象
        File[] fs = f.listFiles();              // 创建文件路径列表的数组
        if (fs == null) {                       // if数组为空，则返回
            return;
        }
        for (File file : fs) {                  // 输出数组
            if (file.isFile()) {
                System.out.println(file.getPath());
            } else {
                test(file.getPath());
            }
        }
    }
}

五、java数组学习

5.1 数组的定义

同一种类型数据的集合

        // 第一种  数组的定义  定义一个存储3个整数的容器
    int [] x = new int[3];
    // 第二种  数组的定义  定义一个存储3个整数的容器
    int [] y = new int[] {2,7,6,9,4,3,3};
    // 第三种  数组的定义  定义一个存储3个整数的容器
    int [] z = {2,7,6,9,4,3,3};

        // 数组定义，二维数组
    // 第一种  数组的定义  
        int [][] arr4 = new int[3][5];
    // 第二种  数组的定义  
        int [][] arr5 = new int[][] {{-2,7,6},{-9,4,3,3}};
    // 第三种  数组的定义  
        int [][] arr6= {{-2,7,6},{-9,4,3,3}};

5.2 数组的操作

package base;

public class Array_learn {
public static void main(String[] args) {
    // 数组定义，一维数组
    // 第一种  数组的定义  定义一个存储3个整数的容器
    int [] arr1 = new int[3];
    // 第二种  数组的定义  
    int [] arr2 = new int[] {-2,7,6,-9,4,3,3};
    // 第三种  数组的定义  
    int [] arr3= {2,7,6,9,4,3,3};
    
    // 数组定义，二维数组
    // 第一种  数组的定义  
        int [][] arr4 = new int[3][5];
    // 第二种  数组的定义  
        int [][] arr5 = new int[][] {{-2,7,6},{-9,4,3,3}};
    // 第三种  数组的定义  
        int [][] arr6= {{-2,7,6},{-9,4,3,3}};
    
    // 打印数组
    printArray(arr2);
    //获取数组中的最大值
    int max = getArrayMax(arr2);
    System.out.println(max);
    //获取数组中的最小值
    int min = getArrayMin(arr2);
    System.out.println(min);
    // 数组的排序之冒泡排序
    bubbleSort(arr2);
    printArray(arr2);
    // 数组的排序之插入排序
    insertSort(arr2);
    printArray(arr2);
    // 数组的排序之选择排序
    selectSort(arr2);
    printArray(arr2);
    // 数组的查找之折半查找
    // 因为折半查找要求数组必须有序，所以先进行排序
    selectSort(arr2);
    int m = halfSearch(arr2,7); 
    System.out.println(m);  // 返回查找的数组下标，如果没有找到返回-1
    }
    // 打印数组
    public static void printArray(int[] y){
        for(int i =0; i<y.length;i++)
        {
            System.out.print(y[i]+"\t");
        }
        System.out.println();
    }
    // 获取数组中的最大值
    public static int getArrayMax(int[] y){
        int max = y[0];
        for(int i =0; i<y.length;i++){
            if(y[i]>max){
                max =y[i];
            }
        }
        return max; 
    }
    //获取数组中的最小值
    public static int getArrayMin(int[] y){
        int min = y[0];
        for(int i =0; i<y.length;i++){
            if(y[i]<min){
                min =y[i];
            }
        }
        return min; 
    }
    // 数组的排序之冒泡排序
    public static void bubbleSort(int[] y) {
        /**
        冒泡排序
        比较相邻的元素。如果第一个比第二个大，就交换他们两个。 [1] 
        对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 [1] 
        针对所有的元素重复以上的步骤，除了最后一个。 [1] 
        持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
        **/
        int temp = 0;
        // 外层循环，它决定一共走几趟
        for (int i = 0; i <y.length-1; ++i) {
        //内层循环，它决定每趟走一次
        for (int j = 0; j <y.length-i-1 ; ++j) {
        //如果后一个大于前一个    换位
        if (y[j + 1] < y[j]) {
            temp = y[j];
            y[j] = y[j + 1];
            y[j + 1] = temp;
            }
        }   
     }
    }
    // 数组的排序之插入排序
    public static void insertSort(int y[]) {
        int i, j;
        for (i = 1; i < y.length; i++) {
        int temp = y[i];
        for (j = i; j > 0 && temp < y[j - 1]; j--) {
        y[j] = y[j - 1];
        }
        y[j] = temp;
        }
        }
    // 数组的排序之选择排序
    public static void selectSort(int y[]) {
        int temp = 0;
        for (int i = 0; i < y.length - 1; i++) {
        // 认为目前的数就是最小的, 记录最小数的下标
        int minIndex = i;
        for (int j = i + 1; j < y.length; j++) {
        if (y[minIndex] > y[j]) {
        // 修改最小值的下标
        minIndex = j;
        }
        }
        // 当退出for就找到这次的最小值
        if (i != minIndex) {
        temp = y[i];
        y[i] = y[minIndex];
        y[minIndex] = temp;
           }
        }
    }
    // 数组的查找之折半查找
    public static int halfSearch(int[] arr,int target) {
        //定义三个变量分别记录最大、最小、中间的查找范围索引值
        int max=arr.length-1;
        int min=0;
        int mid=(max+min)/2;
        while(true) {   
            if(target<arr[mid]) {       //如果目标元素小于中点元素
                max = mid-1;            //max向mid前移动
            }else if(target>arr[mid]) { //如果目标元素大于中点元素
                min = mid+1;            //min向mid后移动
            }else {
                return mid;             //找到目标元素
            }           
            //没有找到的情况
            if(max<min) {
                return -1;
            }           
            //重新计算中间索引值
            mid=(max+min)/2;
        }       
    }   
}

java基础、数组、函数（方法）