Java学习(一)

一. Java运行机制及运行过程

1. java核心机制- java虚拟机 JVM java virtual machine

1.1 基本介绍

JVM是一个虚拟的计算机,具有指令集并使用不同的存储区域,负责执行指令,,管理数据,内存,寄存器,包含在JDK中

对于不同的平台,有不同的虚拟机

java虚拟机机制屏蔽了底层运行平台的差别,实现了"一次编译,到处运行"

1.2. JDK

1. JDK 的全称 Java decelopment KIt java开发工具包,JDK=JRE+java开发工具 [java,javac,javadoc,javap等]

2. JDK 是提供给Java开发人员使用的,其中包含了java的开发工具,也包括了JRE,所以安装了JDK,就不用在单独安装JRE了

1.3.JRE

1. JRE(Java Runtime Environment java 运行环境)

JRE = JVM +java 的核心类库(类)

2. 包括java虚拟机和java程序所需的核心类库等,如果想要运行一个开发好的java程序,计算机中值需要安装JRE即可

1.4 JDK,JRE 和JVM 的包含关系

• JDK=JRE + 开发工具集(例如javac ,java编译工具等)
• JRE = JVM + Java SE标准类库(Java核心类库)
• 如果只想运行开发好的 .class文件 只需要JRE

二. java 快速入门

2.1. 使用Sublime Text 编写代码

1. 编写代码

 public class Hello{
   //编写一个main方法
   public static void main(string[] args){
   	 System.out.println("hellow,world");
   }
 }

1. public class Hello 表示Hello是一个类,是一个public 公有的类

2. hello { } 表示一个类的开始和结束

3. public static void main(String[] args) 表示一个主方法,即我们程序的入口

4. main() { } 表示方法的开始和结束

5. System.out.println("hellow,word"); 表示输出 hello,world 到屏幕

6 ; 表示语句结束

2. 通过终端javac 命令对该java文件进行编译,生成.class文件

javac Hello.java

3. 通过java命令对生成的class文件进行运行

windows: 文件有中文时, 如何处理

在文件 -> 设置文件编码 -> GBK 需要重新保存即可

2.2 什么是编译

Javac Hello.java

1. 有了java源文件, 通过编译器将其编译成JVM可以识别的字节码文件

2. 在该源文件目录下,通过javac编译工具对Hello.java文件进行编译

3. 如果程序没有出错,没有任何提示,但在当前目录下会出现一个Hello.class文件,该文件成为字节码文件,也是可以执行的java的程序

2.3 什么是运行

1. 有了可执行的java程序(Hello.class字节码文件)

2. 通过运行工具java.exe 对字节码文件进行执行,本质就是.class装载到jvm机执行

Java程序开发注意事项:

对修改后的Hello.java 源文件需要重新编译,生成新的class文件后,再进行执行,才能生效

2.4 Java 开发注意事项和细节说明

1. Java源文件以 .java为扩展名. 源文件的基本组成部分是类 class,如本类中的Hello类

2. Java应用程序的执行入口是main()方法,它有固定的书写格式:

public static void main(String[] args){...}

3. Java语言严格区分大小写

4, java方法由一条条语句构成,每个语句以 ":" 结束.

5. 大括号都是成对出现的,缺一不可,习惯,先写{}在写代码

6. 一个源文件中最多只能有一个public类,其它类的个数不限

7. 如果源文件包含一个public类,则文件名必须按该类名命名!

8. 一个源文件中最多只能有一个public类,其它类的个数不限,也可以将main方法写在非public类中,然后指定运行非public类,这样入口方法就是非public的main方法

三. java常用转义字符

1. \t: 一个制表位,实现对齐的功能
2. \n: 换行符
3. \\ : 输出一个\
4. \" : 输出一个"
5. \' : 输出一个'
6. \r : 一个回车

//演示转移字符的使用
public class ChangeChar{
	//编写一个main方法
	public static void main(String[] args){
		// \t :一个制表位,实现对齐功能
		System.out.println("北京\t天津\t上海");
		// \n : 换行符
		System.out.println("jack\nsmith\nmary");
		//  输出\
		System.out.println("C:\\s");
		// 输出 双引号 " "
		System.out.println("学习:\"java\"");
		// 输出 单引号 ' '
		System.out.println("学习:\'学习java\'");

		// \r: 一个回车
		System.out.println("韩顺平教育\r北京");
		//解读 
		//1. 先输出韩顺平教育然后回车 
		//2. 回车后光标回到韩顺平教育前面
		//3  输出北京,会把韩顺替换掉  
		System.out.println("书名\t作者\t价格\t销量\n三国\t罗 贯中");
	}
}

四. 注释

4.1 单行注释 //

4.2 多行注释 /* */

4.3 文档注释

注释内容可以被JDK提供的工具 javadoc所解析,生成一套以网页文件形式体现的该程序的说明文档,一般写在类

/**
 * 这是类的注释
 * @author wufeng
 * @version 1.0
 */
public class Comment02 {

    /**
     * 主方法
     * @param args 参数
     */
    public static void main(String[] args) {
        System.out.println("Hello");
    }
}

运行命令

在当前目录新建 doc 文件夹，把所有javadoc文档全部生成进去

javadoc -d ./doc -author -version Comment02.java

生成文档

五. 代码规范

1. 类,方法的注释,要以javadoc的方式来写

2. 非java Doc的注释,往往是给代码的维护者看的,着重告述读者为什么这么写,如何修改,注意什么问题等

3. 选中文本后，按 Tab 键整体向右移动缩进；按 Shift + Tab 键整体向左移动缩进。

4. 运算符和 = 两边习惯性各加一个空格,比如: 2 + 4 * 5 + 345 - 89

5. 源文件使用utf-8编码

6. 行宽度不要超过80字符

7. 代码编写次行风格和行尾风格

六. Windows DOS(命令)

Dos: Disk Operating System 磁盘操作系统

1.补充: 相对路径: 从当前目录开始定位,形成的一个路径

绝对路径: 从顶级目录D盘,开始定位形成的路径

需求: 从abc\test100 访问 hello.txt

相对路径: ..\..\abc2\test200\hello.txt

绝对路径: d:\abc2\test200\hello.txt

2.常用的dos命令

1. 查看当前目录是有什么内容

(DOS) dir dir d:\abc2\test200

(Mac/Linux) ls /Users/你的用户名/abc2/test200

2. 切换到其他盘下: 盘符号cd

---

(DOS) cd cd/D c:

(Mac/Linux) cd /Users/ 用户名 /abc2/test200

3, 切换到当前盘的其他目录下

DOS) cd 文件夹名

(Mac/Linux) cd 文件夹名

4. 切换到上一级

(DOS) cd..

(Mac/Linux) cd ..

5. 切换到根目录

(DOS) cd

(Mac/Linux) cd /

6. 查看指定的目录下所有的子集目录

(DOS) tree D:

(Mac/Linux) ls -R /Users/ 用户名

7. 清屏

(DOS) cls

(Mac/Linux) clear

8. 退出

(DOS) exit

(Mac/Linux) exit

七. 变量

变量相当于内存中一个数据存储空间的表示,你可以把变量看做是一个房间的门牌号,通过门牌号我们可以找到房间,而通过变量名可以访问到变量(值)

1. 变量使用的基本步骤

声明变量 int a;

赋值 a=60; 把6赋值给a

通常是 int a=60;

打印 System.out.println(a);

2. 变量使用注意事项

1. 变量表示内存中的一个存储区域[不同的变量,类型不同,占用的空间大小不同],比如int 4个字节,double 就是8个字节

2. 该区域有自己的名称[变量名]和类型[数据类型]

3. 变量必须先声明,后使用,就有顺序

4. 该区域的数据可以在同一类型范围内不断变化

5. 变量在同一个作用域内不能重名

6. 变量=变量名+值+数据类型

3. 程序中 + 号的使用

1. 当左右两边都是数值型时,则做加法运算

int a = 10;
int b = 20;
int res = a + b;
System.out.println(res); // 输出：30

2. 当左右两边有一方为字符串,则做拼接运算

String name = "用户";
int age = 22;
String info = name + age;
System.out.println(info); // 输出：用户22

八. 数据类型

8.1 基本数据类型

1.整数类型

• byte 1字节 -128 ~ 217(取值范围)
• short 2字节 -32768 ~32768
• int 4字节 常用默认整型
• long 8字节 超大整数,结尾要加L

byte a =10; 
short b = 10; 
int c = 1000; 
long d = 9999999999L 

2. 浮点类型

• float 4字节 单精度,结尾加F
• double 8字节 双精度,小数默认用它

float f = 3.14F; 
double d = 3.14159; 

3. 字符类型

• char : 2字节,存单个字符,用单引号 ' '

char ch = 'A'

4.布尔类型

• boolean: 只有两个值true / false, 不能和数字互换

boolean flag = true; 
boolean b = false; 

8.2 引用数据类型

1.字符串String 保存一串文本字符 双引号"内容" 默认值: null

特点:

• 引用类型
• 一旦创建不可修改
• • 号可以和任意类型做字符串拼接

2. 数组

类型	定义格式	作用	下标规则	默认值
数组	类型[] 数组名	存放同类型一组数据	从 0 开始	基本类型给 0 / 假，引用给 null

分类:

• 基本类型数组: int[ ] byte[ ] double [ ]
• 引用类型数组: String [ ] 类名[ ]

int[] arr = {10,20,30};
String[] strArr = {"a","b","c"};

8.3.类 / 接口 / 抽象类

1. 类 class

类型	关键字	作用	创建对象方式	默认值
自定义类	class	封装属性和方法	new 类名()	成员变量默认 null

//1. 定义普通类 
class Person{
  String name; 
  int age; 
}

//使用 
public class demo {
  public static void main(String[] args){
    // new 创建对象
    Person p =new Person(); 
    p.name = "张三";
    p.age = 20; 
    System.out.println(p.name + p.age);
  }
}

2. 接口(interface)

类型	关键字	作用	使用方式
接口	interface	定义行为规范、规则	类用 implements 实现

//1. 定义接口 
interface Play {
  //接口方法默认抽象
  void game();
}

//2. 类实现接口
class Student implements Play{
  @Override 
  public void game(){
    System.out.println("学生玩游戏"); 
  }
}

//使用
public class demo{
  public static void main(String[] args){
    Student s = new Student(); 
    s.game();
  }
}

3. 抽象类 (abstract class)

类型	关键字	作用	特点
抽象类	abstract class	半模板、有抽象方法	不能直接 new，只能被继承

// 1. 定义抽象类
abstract class Animal {
  //抽象方法 : 没有方法体 
  public abstract void eat(); 
}

// 2.子类继承抽象类

class Cat extends Animal{
  // 必须重写重写方法 
  @Override 
  public void eat(){
    System.out.println("猫吃鱼");
  }
}

//使用
public class demo{
  public static void main(String[ ] args){
    Cat c = new Cat(); 
    c.eat(); 
  }
}

九. 基本数据类型使用细节

9.1. 整数类型

1. Java各整数类型有固定的范围和字段长度,不受具体操作系统的影响,以包整java程序的可移植性,
2. Java的整型常量默认为int型,声明long型常量须加 'l' 或 'L'
3. Java程序中变量常声明为int型,除非不足以表示大数,才使用long
4. bit: 计算机中的最小存储单位, byte: 计算机中基本存储单位, 1byte = 8 bit

9.2. 浮点类型

1. 与整数类型类似,Java浮点类型也有固定的范围和字段长度,不受具体OS的影响 [float 4个字节, double 是8个字节]
2. Java的浮点型常量默认为double型,声明float型常量,须后加 'f' 或 'F'
3. 浮点型常量有两种表示形式
   十进制数形式: 如: 5.12 512.0f .512(必须有小数点)
   科学计数法形式: 如: 5.12e2[ ] 5.12E-2 [ ]
4. 通常情况下,应该使用double型,因为它比float型更精确
   double num9 = 2.1234567851;
   float num1 = 2.1234567851F;
5. 浮点数使用陷阱: 2.7 和8.1 / 3 比较

double num11 = 2.7;

double num12 = 8.1 / 3;

System.out.println(number11); //1.7

System.out.println(num12); //接近2.7 2.6999999999999997

注意: 当我们对运算结果是小数的进行相等的判断时,要注意. 应该是以两个数的差值的绝对值,在某个精度范围类判断

正确写法 :

差值非常小,到我的规定精度,认为相等

if(Math. abs(num11 - num12) < 0.0000001){

}

System.out.println(Math.abs(num11 - num12)); //4.440892098500626E-16

9.3. 字符类型(char)

1. 字符量是用单引号(' ')括起来的单个字符,例如: char c1 = 'a'; char c2 = '中'; char c3 = '9';
2. java中还允许使用转移字符 '\' 来将其后的字符转变为特殊字符型常量, 例如: char c3 = '/n'; // '\n' 表示换行符
3. 在java中,char的本质是一个整数,在输出时,是unicode码对应的字符
4. 可以直接给char赋一个整数,然后输出时,会按照对应的unicode 字符输出
5. char类型是可以进行运算的,相当于一个整数,因为它都对应有Unicode码

public class CharDemo {
    public static void main(String[] args) {

        // 1. 单引号括起来的 单个字符
        char c1 = 'a';

        // 2. 转义字符 \n 换行
        char c4 = '\n';
        System.out.println("\n2. 转义字符换行：");
        System.out.println("第一行" + c4 + "第二行");

        // 3. char 本质是整数，直接赋值数字输出对应字符
        char c5 = 97;
        System.out.println("\n3. 赋值整数97：");
        System.out.println(c5); // 输出 a

        // 4. 赋值汉字对应的Unicode数字
        char c6 = 20013;
        System.out.println("\n4. 赋值Unicode 20013：");
        System.out.println(c6); // 输出 中

        // 5. char 可以运算，相当于整数
        char c7 = 'a';
        int result = c7 + 10;
        System.out.println("\n5. char运算：");
        System.out.println("'a' 本身的值：" + (int)c7);
        System.out.println("'a' + 10 = " + result);
    }
}

9.4.字符类型本质

1. 字符型存储到计算机中, 需要将字符对应的码值(整数) 找出来,比如 'a'

存储: 'a' ===> 码值 97==> 二进制 ==>存储

读取: 二进制 => 97 ===> 'a' => 显示

2. 字符和码值的对应关系是通过字符编码表决定的(是规定好的)

介绍一下字符编码表[sublime测试]

ASCll (ASCll) 编码表 一个字节表示,一个128 个字符

Unicode (Unicode 编码表 固定大小的编码 使用两个字节来表示字符,字母和汉字统一都是占用两个字节,这样浪费空间)

utf-8(编码表,大小可变的编码字母使用1个字节,汉字使用3个字节)

gbk(可以表示汉字,而且范围广,字母使用1个字节,汉字2个字节)

gb2312(可以表示汉字,gb2312 < gbk)

big5码(繁体中文,台湾,香港)

9.5.布尔类型

1. 布尔类型也叫boolean类型,boolean类型数据只允许取值true和false,无null
2. boolean类型占1个字节.
3. boolean 类型适于逻辑运算,一般用于流程控制[这个后面会详细介绍]:
   if条件控制语句;
   while循环控制语句;
   do-while循环控制语句;
   for循环控制语句
4. 不可以0 或非0的整数替代false 和true

十. 基本数据类型转换

10.1 自动类型转换

当java程序在进行赋值或者运算时,精度小的类型自动转换为精度大的数据类型,这个就是自动类型转换

数据类型按精度(容量)大小排序为(规则)

例如 :

int a ='c' ; //可以自动转换 char - > int

double d = 80; // 对 int => double

System.out.println(num) ; //97

System.out.println(d1) ; //80.0

10.2 自动转换注意和细节

1. 有多种类型的数据混合运算时,系统首先自动将所有数据转换成容量最大的那种数据类型,然后进行计算

2. 当我们把精度(容量)大的数据类型赋值给精度(容量)小的数据类型时,就会报错,反之就会进行自动类型转换

3. (byte,short) 和 char之间不会相互自动转换

4. byte,short,char 他们三者可以计算,在计算时首先转换为int类型

5. boolean 不参与转换

6. 自动提升原则: 表达式结果的类型自动提升为操作数中最大的类型

10.3 基本数据类型转换 练习题

// 基本数据类型转换-练习题
// 判断是否能够通过编译

// 1.
short s = 12; // ok
s = s - 9;    // 错误 int -> short

// 2.
byte b = 10;         // ok
b = b + 11;          // 错误 int -> byte
b = (byte)(b + 11);  // 正确, 使用强转

// 3.
char c = 'a';        // ok
int i = 16;          // ok
float d = .314F;     // ok
double result = c + i + d; // ok float -> double

// 4.
byte b = 16;         // ok
short s = 14;        // ok
short t = s + b;     // 错误 int->short

10.4 基本数据类型和String类型的转换

在程序开发中,我们经常需要将基本数据类型转成String类型,或者将String类型转成基本数据类型

1. 基本数据类型转String

语法: 将基本类型的值 + " " 即可

public class demo {
    public static void main(String[] args) {
        int n1 = 100;
        float f1 = 1.1F;
        double d1 = 4.5;
        boolean b1 = true;

        // 全部转成字符串 拼接
        String s1 = n1 + "";               // int → String
        String s2 = f1 + "";               // float → String
        String s3 = d1 + "";               // double → String
        String s4 = b1 + "";               // boolean → String

        String all = n1 + "" + f1 + "" + d1 + "" + b1;

        System.out.println(all); //1001.14.5true
    }
}

2. String类型转换基本数据类型

语法: 通过基本类型的包装类调用parseXX方法即可

public class demo {
    public static void main(String[] args) {
        String s5 = "123";

        // 1. 字符串 → int
        int num1 = Integer.parseInt(s5);
        
        // 2. 字符串 → double
        double num2 = Double.parseDouble(s5);
        
        // 3. 字符串 → float
        float num3 = Float.parseFloat(s5);
        
        // 4. 字符串 → long
        long num4 = Long.parseLong(s5);
        
        // 5. 字符串 → byte
        byte num5 = Byte.parseByte(s5);
        
        // 6. 字符串 → short
        short num6 = Short.parseShort(s5);
        
        // 7. 字符串 → boolean
        boolean b = Boolean.parseBoolean("true");

        // 输出所有结果
        System.out.println("int 类型：" + num1); //123
        System.out.println("double 类型：" + num2);//123.0
        System.out.println("float 类型：" + num3); //123.0
        System.out.println("long 类型：" + num4);//123
        System.out.println("byte 类型：" + num5); //123
        System.out.println("short 类型：" + num6);//123
        System.out.println("boolean 类型：" + b);// true 

        //怎么把字符串转成字符char  -> 含义是指 把字符串的第一个字符得到 
        //解读 s5.charAt(0) 得到s5字符串的第一个字符 '1'
        System.out.println(s5,charAt(0));
    }
}

注意:

1. 在将String类型转成基本数据类型时,要确保String类型能够转成有效的数据,比如我们可以把 '123',转成一个整数,但是不能把'hello'
2. 如果格式不正确,就会抛出异常,程序就会终止

十一. 强制类型转换

11.1 强制类型转换

自动类型转换的逆过程,将容量大的数据类型转换为容量小的数据类型,使用时要加上强制转换符( ),但可能造成精度降低或溢出,格外要注意.

// 自动类型转换细节
public class demo{
   public static void main(String[] args){
     int i =(int)1.9; 
     System.out.println(i); //1

     int j=100;
     byte b1=(byte)j;
     System.out.println(b1); //100 

     int n2=2000;   
     byte b2=(byte)n2;
     System.out.println(b2);//-48 精度损失 
   }
}

注意:

1. 当进行数据的大小 大---> 小,就需要使用到强制转换

2. 强转符号只针对于最近的操作数有效,往往会使小括号提升优先级

   int x =(int) 10*3.5 +6*1.5; //编译错误: double->int
   //正确写法
   int y=(int)(10*3.5 +6*3.5);
   System.out.println(x); //44

3. char类型可以保存int的常量值,但不能保存int的变量值,需要强转

   // 自动类型转换细节
   public class demo{
      public static void main(String[] args){
         char c1=100; //ok
         int m=100; // ok
         //char c2=m;//错误
         char c3=(char)m; //ok 
         System.out.println(c3); //100对应的字符
      }
   }