深入理解JAVA 之 JAVA的基础语法

1.变量

（1）变量是内存中装载数据的小盒子，你只能用它来存数据和取数据。

（2）变量必须要有明确的类型

（3）定义基本类型变量（创建变量）数据类型  变量名  =  数据值；

例如：int a = 100;

(4)变量不赋值不能使用。变量使用时有作用域的限制。变量不可以重复定义。

（5）变量类型转换：

范围小的数据类型  变量 = (范围小的数据类型) 范围大的数据类型值； 如：int i = (int)6.712 ;  //i的值为6

范围大的数据类型 变量 = 范围小的数据类型值；如：int i=100;double d2=i;

2.引用数据类型

（1）定义引用类型的变量 ：数据类型  变量名  =  new 数据类型();

（2）调用该类型实例的功能 ：变量名.方法名();

扫描二维码关注公众号，回复： 8343936 查看本文章

例如：Scanner类（使用该类来完成用户键盘录入，获取到录入的数据）

Scanner使用步骤：

导包：import java.util.Scanner;

创建对象实例：Scanner sc = new Scanner(System.in);

调用方法：

import java.util.Scanner;

public class demo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        //输入int型的变量i和string类型的变量s
        int i = sc.nextInt();  //用来接收控制台录入的数字
        String s = sc.next();  //用来接收控制台录入的字符串
        //输出i和s
        System.out.println(i);
        System.out.print(s);
    }
    
}

random类（产生多种数据类型的随机数）

random使用步骤:

导包：import java.util.Random;

创建对象实例：Random r = new Random();

方法简介

public int nextInt(int maxValue)     产生[0,maxValue)范围的随机整数，包含0，不包含maxValue；

public double nextDouble()  产生[0,1)范围的随机小数，包含0.0，不包含1.0。

import java.util.Random;

public class demo {
    public static void main(String[] args) {
        // 创建Random类的实例
        Random r = new Random();    
        //public int nextInt(int maxValue)产生[0,maxValue)范围的随机整数
        int i = r.nextInt(); 
        //public double nextDouble()产生[0,1)范围的随机小数，包含0.0，不包含1.0
        double d = r.nextDouble(); 
        System.out.println(i);
        System.out.print(d);
    }
}

 

3.数组

3.1一维数组

（1）定义数组：数据类型[] 数组名 = new 数据类型[元素个数或数组长度];

例如：int[] x = new int[100];

（2）数组的静态初始化有两种方式:

1、类型[] 数组名 = new 类型[]{元素，元素，……};

2、类型[] 数组名 = {元素，元素，元素，……};   

public class demo {
    public static void main(String[] args) {
        // 定义数组
        int[] a = new int[10];
        // 对数组进行静态初始化赋值S
        int[] b = { 4, 5, 6, 7 };
        System.out.println("数组b的元素为：");
        for (int i = 0; i < b.length; i++)
            System.out.print(b[i] + " "); // 4 5 6 7

        System.out.println("\n数组a的元素为：");
        for (int i = 0; i < a.length; i++)
            System.out.print(a[i] + " "); // 0 0 0 0 0 0 0 0 0 0
    }
}

3.2二维数组

（1）定义数组的方式有以下三种：

第一种：int[][] arr = new int[3][4];

定义了一个3*4的二维数组，即二维数组的长度为3，二维数组中的每个元素又是一个长度为4的数组

第二种：int[][] arr = new int[3][];

第二种方式和第一种类似，二维数组的长度为3，但是数组中每个元素的长度不确定

第三种方式：int[][] arr = {{1,2},{3,4,5,6},{7,8,9}};

public class demo {
    public static void main(String[] args) {
        // 定义二维数组
        int[][] a = new int[3][4];
        System.out.println("二维数组a的长度为：" + a.length);
        int[][] arr2 = { { 1, 2 }, { 3, 4, 5 }, { 6, 7, 8, 9, 10 } };
        System.out.println("输出二维数组arr2的元素：");
        for (int i = 0; i < arr2.length; i++) {
            for (int j = 0; j < arr2[i].length; j++) {
                System.out.print(arr2[i][j] +" ");
            }
            System.out.println();
        }
    }
}

4.方法

（1）声明一个方法的具体语法格式如下：

修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2,．．．．．．){ 
    执行语句
    ……… 
    return 返回值;
}

// 下面定义了一个求矩形面积的方法，接收两个参数，其中x为高，y为宽
    public static int getArea(int x, int y) {
        int temp = x * y; // 使用变量temp记住运算结果
        return temp; // 将变量temp的值返回
    }

（2）方法重载

Java允许在一个类中定义多个名称相同的方法，但是参数的类型或个数必须不同，这就是方法的重载

下面的三个方法互为重载关系

public static int add(int x,int y) {逻辑} //两个整数加法

public static int add(int x,int y,int z) {逻辑} //三个整数加法

public static int add(double x,double y) {逻辑} //两个小数加法

public class demo {
    //方法的重载
    public static int myadd(int a,int b){
        return a+b;
    }
    public static double myadd(double a,double b){
        return a+b;
    }
    public static String myadd(String a,String b){
        return a+b;
    }
    public static void main(String[] args) {
    int sum1 = myadd(1,2);
    double sum2 = myadd(1.3,2.6);
    String sum3 = myadd("132","0923");
    System.out.println(sum1);
    System.out.println(sum2);
    System.out.println(sum3);
    }
}

5.ArrayList集合

       ArrayList集合是程序中最常见的一种集合，它属于引用数据类型（类）。在ArrayList内部封装了一个长度可变的数组，当存入的元素超过数组长度时，ArrayList会在内存中分配一个更大的数组来存储这些元素，因此可以将ArrayList集合看作一个长度可变的数组。

5.1.使用步骤

导包：import java.util.ArrayList;

创建对象：与其他普通的引用数据类型创建方式完全相同，但是要指定容器中存储的数据类型：

ArrayList<要存储元素的数据类型> 变量名 = new ArrayList<要存储元素的数据类型>();

注明：“<要存储元素的数据类型>”中的数据类型必须是引用数据类型，不能是基本数据类型

通过举几个例子，来明确集合的创建方式：
存储String类型的元素
ArrayList<String> list = new ArrayList<String>();
存储int类型的数据
ArrayList<Integer> list = new ArrayList<Integer>(); 
存储Phone类型的数据
ArrayList<Phone> list = new ArrayList<Phone>();

5.2  ArrayList集合中常用方法

import java.util.ArrayList;

public class demo {
    
    public static void main(String[] args) {
        //ArrayList类的使用
        ArrayList<Integer> alist = new ArrayList<Integer>();
        alist.add(3);//将元素加入集合的末尾
        alist.add(5);
        for(int i = 0;i<alist.size();i++){//size()得到集合元素个数
            System.out.println(alist.get(i));//get(i)得到指定下标的集合元素
        }
        System.out.println();
        
        alist.add(1,4);//add(index,obj)将指定元素obj插入到集合中指定的位置
        for(int i = 0;i<alist.size();i++){
            System.out.println(alist.get(i));
        }
        System.out.println();
        
        int c = alist.remove(1);//remove（int index）从集合中删除指定index处的元素，返回该元素
        System.out.println("被删除数 c = "+c);
        for(int i = 0;i<alist.size();i++){
            System.out.println(alist.get(i));
        }
        System.out.println();
        
        alist.set(1,9);//set（int index, Object obj）用指定元素obj替代集合中指定位置上的元素
        for(int i = 0;i<alist.size();i++){
            System.out.println(alist.get(i));
        }
        System.out.println();
        
        alist.clear();//clear()清空集合中所有元素
        for(int i = 0;i<alist.size();i++){
            System.out.println(alist.get(i));
        }
        System.out.println();
        
    }
}