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（java runtime environment）
  运行环境

二、语言基础

2.1 编码规范

编码规范

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 运算符

• 赋值运算符

  
  赋值运算符

• 算术运算符

  
  算术运算符

• 关系运算符

  
  关系运算符

• 逻辑运算符

  
  逻辑运算符

• 位运算符

• 移位运算符

• 对象运算符

• 三目运算符
  格式
  布尔表达式?结果1:结果2 //布尔表达式为真，则结果1，布尔表达式为假，则结果2

int age = 18;
String age1 = age == 18?"成年了":"未成年";

2.4 数据类型

数据类型

2.4.1 基本数据类型

• 整数型
• 浮点型
• 字符型
• 逻辑型

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.6 控制台录入

import java.uti1. Scanner
Scanner sc = new Scanner();

sc.nextint();//获得整数
sc.nextdoubl();//获得小数
sc.next();  //获得字符串
sc.next().charAt(0);//获得单个字符

2.7 关键字

java专有词汇

关键字

三、流程控制

3.1 选择

if...else...语句

3.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.3 循环

• 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);
    }

• while循环

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

• 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.4 跳转

• break语句
• continue语句

四、函数

4.1 函数的概念

什么是函数？

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

函数的优点

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

4.2 函数的定义

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

4.3 函数的参数

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

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

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

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

return关键字

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

4.5 函数的重载

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

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;
  }
}

函数的递归

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

// 斐波那契数列
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);
    }
}

java数组学习

数组的定义

同一种类型数据的集合

        // 第一种  数组的定义  定义一个存储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}};

数组的操作

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;
        }       
    }   
}