【java基础】基础小总结

学习java，将自己的心得或总结写下来吧。

Java 标识符

标识符由字母，下划线(_)，美元符($)和数字组成。

标识符不能以数字开头。

标识符不能使java关键字。

标识符对大小写敏感。

Java常用关键字

关键字	用途
boolean, byte, char, double, float, int, long, short ,void	基本类型
new, super, this, instanceof, null	对象创建，引用
if, else, switch, case, default	选择语句
do, while, for	循环语句
break, continue, return	控制转移
try, catch, finally, throw, throws, assert	异常处理
synchronized	线程同步
abstract, final, private, protected, public, static	修饰说明
class, extends, interface, implements, import, package	类，继承，接口，包
native, transient, volatile	其他方法
true, false	布尔常量

注意：

java中 的关键字均为小写字母，TRUE，NULL等不是关键字。

goto和const虽然在java中午作用，但仍是java的关键字。

java注释

单行注释符：//

//这是单行注释符

多行注释符：/*……*/

/*

这是多行注释符

*/

文档注释：/**……*/

/**
  * 文档注释能被java文档化工具javadoc识别处理，在自动生成文档是有用
  */ 

Java数据类型

Java数据类型包括简单数据类型（基本类型）和复合数据类型（引用类型）

基本类型：代表语言能处理的基本数据。特点：占用的存储空间固定。

整数类型：byte，short，int，long

浮点类型：float，double

字符类型：char

布尔类型：boolean

引用类型：通常由多个基本数据类型或引用类型组合构成。

类：class

接口：interface

数组

【注意】java的字符串其实是String类的常量，它不是java数据类型。

关键字		数据类型		所占字节	默认值	取值范围
byte		字节型		1	0	-2^7 ~ 2^7-1
short		短整型		2	0	-2^15 ~ 2^15-1
int		整型		4	0	-2^31 ~ 2^31-1
long		长整型		8	0	-2^63 ~ 2^63-1
float		单精度浮点型		4	0.0F	1.4e^-45 ~ 1.4e^-45-1
double		双精度浮点型		8	0.0D	4.9e^-324 ~ 1.798e^+308
char		字符型		2	0	0 ~ 65535
boolean		布尔型		1	false	true, false

常量

布尔常量：true，false

整数常量：有byte，short，int，long四种类型。有十进制，八进制，十六进制，二进制四种表示形式。

浮点常量：有float和double类型。有小数点形式和指数形式两种。

字符常量：由一对单引号括起来的单个字符或以反斜线（\）开头的转义字符。如'j', '4'。

常用转义字符

转义字符	描述
\'	单引号字符
\''	双引号字符
\\	反斜杠
\r	回车
\n	换行
\f	走纸换页
\t	横向跳格
\b	退格

字符串常量：有双引号括起来的由0个或多个字符组成的字符序列。字符串可以包含转义字符。

变量的取值范围

/**
* Create by libra
*/

public class VariablesDemo {
    /**变量的取值范围*/
    public static void main(String[] args) {
        System.out.println("数据的取值范围：");
        System.out.println("字节型： " + Byte.MIN_VALUE + " ~ " + Byte.MAX_VALUE);
        System.out.println("短整型： " + Short.MIN_VALUE + " ~ " + Short.MAX_VALUE);
        System.out.println("整型型： " + Integer.MIN_VALUE + " ~ " + Integer.MAX_VALUE);
        System.out.println("长整型： " + Long.MIN_VALUE + " ~ " + Long.MAX_VALUE);
        System.out.println("单精度浮点型： " + Float.MIN_VALUE + " ~ " + Float.MAX_VALUE);
        System.out.println("双精度浮点型： " + Double.MIN_VALUE + " ~ " + Double.MAX_VALUE);

    }
}

输出结果：

强制转换

格式：变量 = (数据类型) 表达式

基本数据类型自动转换顺序：byteàshortàcharàintàlongàfloatàdouble.

【注意】布尔类型不能与其他类型转换。

运算符

运算符（双目单目）稍微提下，位运算符。

算数运算符：

算数运算符
双目运算符	单目运算符
+, -, *, /, %	++, --, -(负号)

关系运算符：

运算符优先级：(==,--) > ~ > ! > 算术运算符>移位运算符>关系运算符> &，^, | , &&, ||, ||

常用数学函数Math类

方法		功能
int abs(int i)		求整数的绝对值
double ceil(double d)		求不小于d的最小整数
double floor(double d)		求不大于d的最大整数
int max(int i1, int i2)		求两个整数中的最大数
int min(int i1, int i2)		求两个整数中的最小数
double random()		0~1的随机数
int round(float f)		求最靠近f的整数
long round(double d)		求最靠近d的长整数
double sqrt(double a)		求平方根
double cos(double d)		求d的余弦函数
double log(double d)		求自然对数
double exp(double x)		求e的x次幂（e^x）
double pow(double a, double b)		求a的次幂

输入输出

标准输出流System.out提供三种输出：

print()：输出后不换行

println()：输出后换行

printf()：类似于c语言中的printf()用法

标准输入流System.in提供read()等方法。写一个程序便于说明及理解。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Input {
    public static void main(String[] args) throws IOException {
        System.out.println("==============字符==============");
        char ch = (char) System.in.read();
        System.out.println("读入的字符为：" + ch);
        System.out.println("==============字符串==============");
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String s = in.readLine();
        System.out.println("读入的字符串为：" + s);
        System.out.println("==============数字==============");
        String x = "123";
        int m = Integer.parseInt(x);
        String y = "123.123";
        float n = Float.parseFloat(y);
        System.out.println("x = " + x);
        System.out.println("y = " + y);
    }
}

输出结果：

还可以使用java.util.Scanner类输入：

import java.util.Scanner;

public class Input {
    public static void main(String[] args) throws IOException {
        Scanner s = new Scanner(System.in);
        System.out.println("请输入数据：");
        System.out.println("请输入数据：");
        short a = s.nextShort();    //输入短整数
        int b = s.nextInt();    //输入整数
        long c = s.nextLong();    //输入长整数
        float d = s.nextFloat();    //输入单精度浮点型
        double e = s.nextDouble();    //输入双精度浮点型
        String f = s.nextLine();    //输入字符串
        System.out.println("a = " + a);
        System.out.println("b = " + b);
        System.out.println("c = " + c);
        System.out.println("d = " + d);
        System.out.println("e = " + e);
        System.out.println("f = " + f);
    }
}

输出结果：

在Scanner中还有很多输入。

流程控制语句和c/c++没有太大区别。

【注意】循环结构体中可以用break 标号名; 和continue 标号名; 来跳出循环。

数组

一维数组声明有两种格式:

1.数组元素类型 数组名[];

2.数组元素类型[] 数组名;

建议用第二种声明方式

【建议】二维数组及多维数组声明方式类似于一维数组，不过建议大家用第二种数组声明方式，[]也是数组声明的组成部分。

【注意】

1.java数组和c/c++数组不同，java数组理解为数组的数组，数组的每一维的大小不一定相同。

例如：

int[][] a = new int[2][];
a[0] = new int[3];
a[1] = new int[4];

上面这段代码声明了一个二维数组，但是第0维和第1维的大小不相同。

2.求一维数组a长度经常用到的方法是a.length。若是多维数组也可以这样用：a[i].length，a[i][j].length ……。

对象

对象的初始化和构造方法以及变量的作用域在一个例子中说明。

public class Scope {
    //成员变量的作用域是整个类体
    int x;
    int y;

    /*对象的初始化*/
    {
        x = 2;
        y = 1;
    }

    /*对象的构造方法*/
    public Scope {
        x = 2;
        y = 1;
    }

    //方法参数a的作用域是整个方法
    public void method(int a) {
        int x = 5;
        for (int i = 1; i < a; i++) {
            //局部变量i的作用域是for循环内
            x = x + i;
        }
        System.out.println("x = " + x + ", y = " + y + ", a = " + a);
    }

    public static void main(String[] args) {
        //局部变量x的作用域从它的声明点扩展到它被定义的代码块结束
        Scope x = new Scope();
        x.method(6);
    }
}

【注意】构造方法的名称必须与类名相同；构造方法无返回类型；一个类可以提供多个构造方法，系统自动调用参数匹配的构造方法。

静态变量和静态方法

用static修饰的成员变量叫静态变量，也叫类变量。

访问：

在本类中直接访问。

通过类名访问。

通过类的一个对象访问。

【注意】静态变量的在存储上归属类空间，但是不依赖任何对象；（通过对象访问静态变量实质上还是访问类空间的变量）

【建议】在类外访问静态变量时通过类名访问以防混淆。

赋初值：即可以通过下面代码块赋初值，也可在定义时赋初值。

static {
//code
}

【注意】静态代码块只能访问静态变量；对象的创建不会执行static代码块。注意区分静态空间和对象空间。

class TalkPlace {
    static String talkArea = "";
}

public class User {
    static int count = 0;
    String username;
    int age;

    public User(String name, int yourage) {
        username = name;
        age = yourage;
    } 

    void Login() {
        //直接访问同一类中的静变量
        count++;
        System.out.println("you are no " + count + " user");
    }

    void Speak(String words) {
        //访问其他类的类变量，通过类名访问类变量
        TalkPlace.talkArea = TalkPlace.talkArea + username + "说： " + words + "\n";
    }

    public static void main(String[] args) {
        User x1 = new User("张三", 20);
        x1.Login();
        x1.Speak("hello");
        User x2 = new User("李四", 16);
        x2.Login();
        x2.Speak("good morning");
        x1.Speak("bye");
        System.out.println("-----讨论区内容如下：");
        System.out.println(TalkPlace.talkArea);
    }
}

用static修饰的方法叫静态方法，也叫类方法。

调用：

一般用类名做前缀调用。

通过对象调用

【注意】静态方法也不依赖任何对象；静态方法中只能处理静态变量和其他静态方法，绝不能访问任何归属对象空间的变量和方法。

public class FindPrime2 {
    public static boolean prime(int n) {
        for (int k = 2; k <= Math.sqrt(n); k++) {
           if (n % k == 0) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        // FindPrime2 a = new FindPrime2();
        for (int m = 10; m <= 100; m++) {
            //prime为静态方法，则可直接调用
            if (prime(m)) {
                   System.out.print(m + " ");
            }
        }
    }
}