java基础语法

2018-12-04  本文已影响0人  上炼致知

关键字

指赋予特殊含义，具有专门用途的单词，如class、int、static、void等。

标志符

就是给类、接口、方法、变量等起的名字。

组成规则：a～z、A～Z、0～9、$、_ 不能以数字开头，不可以使用关键字。

  （必须以字母、下划线、或$符号开头，不能用数字开头）
命名规则：
  a.包名：多单词组成时，所有字母小写，使用点号连接，如aaa.bbb.ccc
  b.类名或接口名：大驼峰式，如AaaBbbCcc
  c.变量名或方法名：小驼峰式，如aaaBbbCcc
  d.常量名：多单词组成时所有字母大写，使用下划线连接，如AAA_BBB_CCC

常量：

常量就是不变的数据量，执行过程中值不变。

数据类型：

Java语言是强类型语言。
基本数据类型：
  整数（byte、short、int、long）
  小数（float、double）
  字符（char）
  布尔（boolean）
引用数据类型：
  强大的数据类型，基于基本数据类型创建。

整数不同进制表示法：

  a.十进制：正常数字，如12，25
  b.二进制：以0b（0B）开头，如0b1011、0B1001
  c.十六进制：以0x（0X）开头，由0～9和A～F组成，如0x23A2、0xa、0x10
  d.八进制：以0开头，如01、0721

字符和字符串简单区别：

  字符：字符必须使用' '（单引号）括起来，并且必须包含且只能包含一个字符
  字符串：字符串是一种引用类型，必须使用""（双引号）括起来，其中可以包含0～N哥字符

基本类型（4类8种）：
四类 八种 字节数 数据表示范围
整型 byte 1 -128～127
整型 short 2 -32768～32767
整型 int 4
整型 long 8
浮点型 float 4
浮点型 double 8
字符型 char 2 表示一个字符，如'a'、'A'
布尔型 boolean 1 只有两个值true和false

java中默认的整数类型是int
java中默认的浮点类型是double

数据类型转换（两种方式）：

自动类型转换：范围小的数据类型转换成范围大的数据类型

double d = 100;
或
int i = 100;
double d2 = i;

强制类型转换：范围大的数据类型转换成范围小的数据类型

int i = (int) 6.718;
或
double d = 3.14;
int i2 = (int)d;

Scanner类
​ Scanner类是引用数据类型的一种，Scanner使用步骤如下：

//创建Scanner引用类型的变量
Scanner sc = new Scanner(System.in);
//获取数字
int n = sc.nextInt();
//获取字符串
String str = sc.next();

随机数类Random
​ 用来产生随机数的类Random，也是引用数据类型，使用如下：

//创建Random类的实例
Random r = new Random();
//得到0～100(不包含100)范围内的随机整数
int i = r.nextInt(100);
//得到0.0~1.0(不包含1.0)范围内的随机小数
double d = r.nextDouble()
最简单的无限循环：

while(ture){} 或 for(;;){}

跳转语句（break、continue）
1、break

​ break用在switch条件语句中时，作用是终止某个case并跳出switch；
​ break用在循环语句中时，作用是跳出循环语句，执行后面的代码；

2、标记

​ 当break出现在嵌套循环中的内存循环时，它只能跳出内层循环。如果想使用break语句跳出外层循环则 需要对外层循环添加标记。

itcast:
for (int i = 0; i <= 9; i++) { //外层循环
    for (int j = 0; j <= i; j++) {  //内层循环
        if (i > 4) {
            break itcast;   //跳出外层循环
        }
    }
}
3、continue

​ continue语句在循环语句总，作用是：终止本次循环，执行下一次循环。

Switch

当条件判断较多时，可以用switch语句来实现。例子如下：

int weeek = 5;
switch (week) {
    case 1: 
        System.out.println("星期一");
        break;
    case 2:
        System.out.println("星期二");
        break;
    default:
        System.out.println("其他工作日和周末");
        break;
}

在jdk1.7之后，switch语句中的表达式为byte、short、char、int、enum、String类型。

在switch语句中，如果多个case条件后面的执行语句是一样的，则该执行语句只需写一次即可，例子如下：

int week = 2;
switch (week) {
    case1:
    case2:
    case3:
    case4:
    case5:
        Sytem.out.println("今天是工作日");
        break;
    case6:
    case7:
        System.println("今天是休息日");
        break;
}
JVM内存划分

JVM对自己的内存划分为5个区域：

a：寄存器：内存和cpu之间；

b：本地方法栈：jvm调用了系统中的功能；

c：方法区和数据共享区：运行时期class文件进入的地方；

d：方法栈：所有的方法运行的时候进入内存；

e：堆：存储的是容器和对象；

数组

数组变量保存的是数组在内存中的地址；数组初始化3种方式：

1.动态初始化 int[] arr = new int[3]
2.静态初始化 int[] arr = new int[]{1, 2, 3}
3.静态初始化（简便，推荐） int[] arr = {1, 2, 3}

二维数组

定义二维数组的三种方式：

1、int[][] arr = new int[3][4]

2、int[][] arr = new int[3][] 这种方式和第一种方式类似，只是内层数组的长度不确定。

3、int[][] arr = {{1,3}, {3,4,5,6}, {7,8.9}}

方法

方法的语法格式如下：

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

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){}
参数传递
引用数据类型--类
自定义类的内存图
对象内存图.JPG
类中的属性，跟随容器进入到内存，属性进入内存，赋予默认值；
两个引用类型变量内存图
两个引用变量内存图.JPG
创建引用类型的变量，只要new了，内存中就会开辟一个新的内存空间，内存中将有自己的属性;
ArrayList创建变量的步骤
//数据类型<集合存储的数据类型> 变量名 = new 数据类型<集合存储的数据类型>();
ArrayList<String> array = new ArrayList<String>();
ArrayList<Integer> array = new ArrayList<Integer>();
//集合存储的数据类型：要将数据存储到集合的容器中;存储引用类型，不存储基本类型
//创建集合引用变量的时候，必须要指定好存储的类型是什么
ArrayList的常见方法

add(param) 向集合中添加元素

ArrayList<String> array = new ArrayList<String>();
array.add("abc");

get(int index) 取出集合中的元素

String a = array.get(0);

size() 返回集合的长度，集合存储元素的个数

int size = array.size();
ArrayList的补充方法

add(int index, param) 将元素添加到指定的索引上

ArrayList<Integer> array = new ArrayList<Integer>();
array.add(2, 7);

set(int index, param) 对指定索引上的元素进行修改

array.set(0, 10);

remove(int index) 删除指定索引上的元素

array.remove(4);

clear() 清空集合中的所有元素

array.clear();
ASCII编码编码表

计算机中，所有的数据在存储和运算时都要使用二进制数表示。

对应ASCII编码十进制：

0～9：对应48～57；A～Z对应65～90；a～z对应97～122；
char类型的存储
1、char转成int类型的时候，类型自动提示，char数据类型，会查询编码表，得到整数；
2、int转成char类型的时候，强制转换，会查询编码表；
3、char存储汉字，查询unicode编码表
4、char可以和int计算，提示为int类型，内存中寸两个字节
数组逆序
public static void reverse(int[] array) {
    for(int min = 0, max = array.length - 1; min < max; min++, max--) {
        int temp = array[min];
        array[min] = array[max];
        array[max] = temp;
    }
}
选择排序
//数组中的每个元素都进行比较
public static void selectSor(int[] array) {
    //外循环，控制的是一共比较了多少次
    for (int i = 0; i < array.length - 1; i++) {
        //内循环，控制的是每次比较了多少个元素
        for (int j = i; j < array.length - 1; j++) {
            if (array[j + 1] < array[i]) {
                int temp = array[i];
                array[i] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
}
冒泡排序
//数组中的相邻元素进行比较
public static void bubbleSor(int[] array) {
    //数组循环的圈数为数组长度-1
    for (int i = 0; i < array.length - 1; i++) {
        for (int j = 0; j < array.length - 1; j++) {
            if (array[j + 1] < array[j]) {
                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
}
数组的折半查找(二分查找)
/**
 * 1.定义三个变量 min mid max
 * 2.循环条件 min <= max
 * 3.goal > arr[mid]  min = mid + 1
 *   goal < arr[mid]  max = mid - 1
 *   goal == arr[mid] find
 * 4.循环结束，无法折半，元素没有找到
 */
public static int binarySearch(int[] array, int goal) {
    int min = 0;
    int max = array.length - 1;
    int mid = 0;
    while (min <= max) {
        mid = (min + max) / 2;
        if (goal < array[mid]) {
            max = mid + 1;
        } else if (goal > array[mid]) {
            min = mid + 1;
        } else {
            System.out.println("find the goal, the goal index is: " + mid);
            return mid;
        }
    }
    System.out.println("the goal is not in the array");
    return  -1;
}
上一篇下一篇

猜你喜欢

热点阅读