JAVA基础

JAVA基础

输出HelloWorld

1. 创建后缀名.java文件->Hello.java

2. 编写代码

   public class Hello{
   	public static void main(String[] args){
   		System.out.print("Hello,World!");
   	}
   }
   

3. 进入cmd，路径是当前的Hello.java的路径

4. 编译，javac Hello.java

5. 运行，java Hello!

   

注意事项

• 注意大小写，JAVA对大小写敏感
• 文件名和类名必须保持一致，即Hello.java与public class Hello的Hello要保持一致，并且首字母大写
• 尽量使用英文

JAVA的运行机制

高级语言的运行机制

在计算机上执行一个高级语言程序一般要分两步，第一步，用一个编译程序将高级语言程序翻译成机器语言程序;第二步，运行所得的机器语言程序求得计算结果。

计算机高级语言按程序的执行方式分为两种:编译型和解释型。

• 编译型语言

  • 编译型语言是指使用专门的编译器，针对特定平台将某种高级语言源代码一次性编译成可被平台硬件执行的机器码，并包装成该平台所能识别的可执行性程序的格式，这个过程称为编译（Compile）。编译生成的可执行性程序可以脱离开发环境，在特定的平台上运行。有些程序编译结束后，还可能需要对其它编译好的目标代码进行链接，组装两个以上的目标代码模块生成最终的可执行性程序。

  • 编译型语言一次性地编译成机器码，所以可以脱离开发环境独立运行而且通常运行效率较高;因为编译型语言的程序被编译成特定平台上的机器码，因此编译生成的可执行性程序通常不能移植到其他平台上运行。典型的编译型程序语言有C、C++等。

• 解释型语言

  • 解释型语言是指使用专门的解释器对源程序逐行解释成特定平台的机器码并立即执行的语言。解释型语言通常不会进行整体的编译链接处理，解释型语言相当于把编译型语言中的编译和解释过程混合到一起同时完成。

  • 解释型语言每次执行程序都要进行一次编译，因此解释型语言的程序运行效率通常比较低，而且不能脱离解释器独立运行。但解释型语言跨平台比较容易，只需提供解释器即可，每个特定平台上的解释器负责将源程序解释成特定平台上的机器指令即可。这种跨平台的优势是以牺牲程序的运行效率为代价的。典型的解释型语言有Ruby、Python等。

JAVA的运行机制

• 编写

  • 编写是指在Java开发环境中进行程序代码的编辑，最终生成后缀名为“.java”的Java源文件。

• 编译

  • 编译是指使用Java编译器对源文件进行错误排查的过程，编译后将生成后缀名为.class的字节码文件，该文件可以被Java虚拟机（JVM）的解释器正常读取。

• 运行

  • 运行是指使用Java解释器将字节码文件翻译成机器代码，执行并显示结果。字节码文件是一种和任何具体机器环境及操作系统环境无关的中间代码，它是一种二进制文件，是Java源文件由Java编译器编译后生成的目标代码文件。编程人员和计算机都无法直接读懂字节码文件，它必须由专用的Java解释器来解释执行，因此Java是一种在编译基础上进行解释运行的语言。

  • 在运行Java程序时，首先会启动JVM，然后由它来负责解释执行Java的字节码，并且Java字节码只能运行于JVM之上。这样利用JVM就可以把Java字节码程序和具体的硬件平台以及操作系统环境分隔开来，只要在不同的计算机上安装了针对于特定具体平台的JVM，Java程序就可以运行，而不用考虑当前具体的硬件平台及操作系统环境，也不用考虑字节码文件是在何种平台上生成的。JVM把这种不同软硬件平台的具体差别隐藏起来，从而实现了真正的二进制代码级的跨平台移植。JVM是Java平台无关的基础，Java的跨平台特性正是通过在JVM中运行Java程序实现的。

内容节选自：

https://www.jianshu.com/p/e502cd90de17

https://zhuanlan.zhihu.com/p/54371311

使用IDEA编写JAVA代码

创建项目的步骤一般：

1. 创建空的项目

2. 创建模组

   

3. 配置项目的环境，File->Project Structure

   

4. 在Modules中添加文件夹

5. 在src文件夹下添加JAVA文件，开始写代码

提示：

• 一般在src文件夹下创建Java文件写代码
• 快捷编写psvm与sout
• 可在网上查IDEA优化设置来改进IDEA

注释

//单行注释

/*
多行注释(/*+回车)
*/

//文档注释,与多行注释有点不同,例子如下(/**+回车)
/**
*@Description Helloworld
*@Author xxx
*/

标识符、关键字

标识符注意事项

• 所有的标识符都应该以字母、美元符号($)或者下划线开始
• 首字符之后可以是字母、美元符号、下划线和数字的任何字符组合
• 不能使用关键字作为变量名或方法
• 标识符是大小写敏感的
• 可以使用中文名命名，但一般不建议这样用，也不建议用拼音，比较LOW

关键字

数据类型

• 强类型语言
  • 要求变量的使用要严格符合规定，所有变量必须先定义后才能使用
• 弱类型语言

Java的数据类型分为两大类

• 八大基本数据类型(primitive type)

  • 数值类型

    • 整数类型

      • byte(1个字节):-128-127

      • short(2个字节):-3,2768-3,2767

      • int(4个字节):-21,4748,3648-21,4748,3647

      • long(8个字节):-922,3372,0368,5477,5808-922,3372,0368,5477,5807

    • 浮点类型

      • float(4个字节)

      • double(8个字节)

    • 字符类型

      • char(2个字节)

  • 布尔类型

    • boolean(占1位): true 或者false

• 引用数据类型(reference type)

  • 类
  • 接口
  • 数组

//整数
int num1 = 10;
byte num2 = 20;
short num3 = 30;
long num4 = 40L;	//Long类型要在数字后面加个L

//浮点数
float num5 = 3.13F;		//float类型要在数字后面加个F
double num6 = 3.1446441344452346;

//字符
char name1 = '中';

//字符串
String name2 = "飞龙在天";		//字符串要用双引号，用单引号会报错

//布尔值
boolean flag = true;

提醒

• 字符串类型的首字母要大写String
• long类型要在数字后面加个L
• float类型要在数字后面加个F
• 字符串要用双引号，用单引号会报错

数据类型扩展

进制拓展

//二进制0b开头，八进制0开头，十六进制0x开头
int i = 10;
int i2 = 010;		//八进制的8
int i3 = 0x10;		//十六进制的16

浮点数拓展

浮点数存在误差问题，最好避免完全使用浮点数进行比较。应使用BigDecimal类，是一个数学工具类。

字符类拓展

//强制转换，涉及到编码问题
char c1 = 'a';
char c2 = '中';
System.out.println((int)c1);		//输出97
System.out.println((int)c2);		//输出20013

char c3 = '\u0097';
System.out.println(c3);		//输出a

常用转义字符

\t	tab键
\n	换行

类型转换

这幅图大致按照容量从低到高排列，至于float比long高的原因是浮点数比整数的优先级更高。这幅图有助于记住哪种是强制类型转换或自动类型转换。

运算时，不同类型的数据先转换为同一类型，然后再进行运算。

//强制类型转换(高->低)
int i = 10;
byte b = (byte)i;	//(类型)变量名

//自动类型转换(低->高)
int i = 10;
double b = i;	//不需要任何操作，自动转换

//类型转换可能遇到的问题
//内存溢出
int i = 128;
byte b = (byte)i;
System.out.println(b);		//输出了-128

//精度问题
double b = 12.34;
int i = (int)b;
System.out.println(i);		//输出了12

注意

• 不能对布尔值进行转换
• 不能把对象类型转换为不相干的类型
• 在把高容量转换到低容量时，强制转换
• 转换的时候可能存在内存溢出或精度问题

例子（可能会出现的溢出问题）

public class demo2 {
    public static void main(String[] args) {
        //操作比较大的数时，注意溢出问题
        //JDK7新特性，数字之间可以用下划线分割
        int money = 10_0000_0000;
        System.out.println(money);      //下划线不会输出

        int years = 20;
        int total = money * years;
        System.out.println(total);      //输出了-1474836480，溢出了

        long total2 = money * years;
        System.out.println(total2);     //输出了-1474836480，还是溢出了

        //应该先将money和years转换成long类型再计算
        long total3 = (long)money * years;
        System.out.println(total3);     //输出20000000000，计算正确
    }
}

变量、常量、作用域、规范

变量

Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

//数据类型 变量名 = 值; 可以使用逗号隔开来声明多个同类型变量，但不建议。
int a=1, b=2, c=3;		//不建议

int a = 1;
int b = 2;
int c = 3;

变量的作用域

• 类变量
• 实例变量
• 局部变量

public class Demo3 {

    //类变量 static
    static double salary = 2500;

    //实例变量：从属于对象，如果不自行初始化，则输出这个类型的默认值,布尔值默认值是false
    //除了基本类型，其余的默认值都是null
    String name;
    int age;

    //main方法
    public static void main(String[] args) {

        //局部变量:必须声明和初始化
        int i = 1;
        System.out.println(i);

        //使用实例变量
        //变量类型 变量名字 = new Demo3();
        Demo3 demo3 = new Demo3();
        System.out.println(demo3.age);      //输出默认值0
        System.out.println(demo3.name);     //输出默认值null

        //类变量,可以直接用
        System.out.println(salary);     //输出2500.0
    }
}

常量

初始化后不能再改变值，常量名一般使用大写字符

//final 常量名 = 值;
final double PI = 3.14;

public class Demo4 {

    //修饰符不分先后顺序，即static与final不分先后顺序
    static final double PI = 3.14;

    public static void main(String[] args) {
        System.out.println(PI);		//输出3.14
    }
}

变量的命名规范

• 所有变量、方法、类名：要见名知意
• 类成员变量：首字母小写和驼峰原则：monthSalary,即除了第一个单词以外，后面的单词首字母大写
• 局部变量：首字母小写和驼峰原则
• 常量：大写字母和下划线：MAX_VALUE
• 类名：首字母大写和驼峰原则：Man, GoodMan
• 方法名：首字母小写和驼峰原则：run(), runRun()

基本运算符

重点掌握前4个，后3个了解即可。

算术、关系运算符

public class Demo01 {
    public static void main(String[] args) {
        //ctrl + D键：复制当前行到下一行
        long a = 100_000_0000;
        int b = 20;
        byte c = 30;
        short d = 40;
        int e = 10;

        //算术运算符
        System.out.println(a+b+c+d);        //不同类型相加转换成long类型，输出1000000090
        System.out.println((double)e/b);       //不先转换成double，将输出0，需要注意
        System.out.println(b+c+d);      //变成int类型，输出90

        //关系运算符
        System.out.println(a>b);        //输出true
        System.out.println(a<b);        //输出false
        System.out.println(a==b);       //输出false
        System.out.println(a!=b);       //输出true
        
    }
}

注意

• 在两个或多个操作数中，若一个操作数为long类型，则算术运算的结果为long类型，若没有long类型时，所有整数类型算术运算时将转换为int类型
• 对于浮点类型也类似，在两个或多个操作数中，若一个操作数为double类型,算术运算的结果为double类型
• 关系运算符返回的结果只有：true或false

自增自减运算、Math类

自增自减

public class Demo02 {
    public static void main(String[] args) {
        //自增运算 ++ 
        int a = 2;
        int b = a++;
        System.out.println(b);      //输出2
        System.out.println(a);      //输出3
        
    }

}

表明a++这条式子等于a，更详细来说就是a++先将a给b赋值，再自增

public class Demo03 {
    public static void main(String[] args) {
        //自增运算 ++
        int a = 2;
        int b = ++a;
        System.out.println(b);      //输出3
        System.out.println(a);      //输出3
    }
}

表明++a这条式子等于a+1，更详细来说就是++a先将a加1，再将a加1的值赋给b

自减运算同理

Math类

//幂运算
double pow = Math.pow(2,3);
System.out.println(pow);        //输出8.0

Math类还可以实现很多，诸如绝对值，最大值等等运算

逻辑运算符

public class Demo05 {
    public static void main(String[] args) {
        //逻辑运算 &&(与) ||(或) !(非)
        boolean a = true;
        boolean b = false;
        System.out.println(a&&b);       //输出false
        System.out.println(a||b);       //输出true
        System.out.println(!a);     //输出false

        //短路运算，即a&&b中，发现a是假，则不会再验证b的结果，直接输出false
        int c = 2;
        System.out.println((c>3)&&(c++<5));     //输出false
        System.out.println(c);      //输出2，表明后面的c++并没有执行

    }
}

位运算符

public class Demo06 {
    public static void main(String[] args) {
        //位运算符 &(与) |(或) ^(异或,相同为0，不同为1) ~(非) <<(左移) >>(右移)

        /*
        A = 0011 1100
        B = 0000 1101
        A&B = 0000 1100
        A|B = 0011 1101
        A^B = 0011 0001
        ~A = 1100 0011

        一道面试题，2*8怎样运算最快？
        2*8 = 16 = 2*2*2*2
        使用位运算，左移相当于乘2，右移相当于除2，位计算效率极其高！！！
         */

        //位移运算，<<相当于乘2，>>相当于除2
        System.out.println(3<<1);       //输出6
        System.out.println(4>>1);       //输出2

    }
}

条件运算符

public class Demo07 {
    public static void main(String[] args) {
        //x ? y : z
        //如果x为true,则为y,否则为z
        int score = 80;
        String type = (score>60) ? "及格" : "不及格";
        System.out.println(type);       //输出及格

    }
}

扩展赋值运算符

a += b;		//相当于a = a + b,其他同理

字符串连接符(面试题)

public class Demo08 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;

        //字符串连接符 +
        System.out.println(""+a+b);     //输出1020,+号前面是空字符串，后面的a和b都转换成字符，所以输出1020
        System.out.println(a+b+"");     //输出30，这里空字符串在+号后面，前面的a和b照常运算，所以输出30
        System.out.println(a+b+""+c);       //输出3030，空字符串前面的a和b照常运算，后面的c进行了字符串连接
    }
}

包机制

为了更好地组织类，Java提供了包机制用于区别类名的命名空间。

包的本质就是文件夹。

在IDEA中新建包

新建包后，IDEA会自动在首行添加包语句的信息，如

包语句的语法格式为

包语句需放在最上面。

一般利用公司域名倒置作为包名，如com.baidu.www

使用import语句进行导包，语句格式为

如

import com.feng.base.Demo1;
import com.feng.base.*;		//*代表base下所有的类

该条语句需在包语句的下面，放在包语句上面会报错。

不要让不同包里面的类的名字相同，否则在导入时会报错。

JavaDoc生成文档

package com.feng.base;

/**
 * @author feng
 * @version 1.0
 * @since 1.8
 */

public class Doc {
    String name;

    /**
     * @author feng
     * @version 1.0
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception{
            return name;
        }
}

加在类上面就是类的注释，加在方法上面就是方法的注释。

使用cmd命令行生成Doc文件

1. 使用cmd进入文件目录，然后输入

   

   javadoc -encoding UTF-8 -charset UTF-8 Doc.java
   

   javadoc命令用来生成自己的API文档

2. 打开目录下的index.html

   

   点进Doc将有更多的详细信息

   

使用IDEA生成JavaDoc文档

1. 打开 idea，点击 Tools-> Generate JavaDoc，打开生成 javadoc 文档的配置页面