概述

构成：

JDK、JVM、JAR
JDK，javadevelopmentkit
JVM，javavirtual machine
JAR，java runtime Environment

jdk文件目录

java命名规则：

1、标识符可以是以任意大小写入字母、数字、下划线、美元符号组成。
但是不可以以数字开头，且严格区分大小写，不能是java的关键字

面向对象（OOP）
三大特征，封装、继承、多态

注释的方式：

1、单行注释
2、多行注释
3、文档注释，可以和JavaDoc联合使用

/**
 *文档注释
 *
 */

标识符和关键字

标识符：java所有的组成部门后需要名字，类名、变量名、以及方法名都为成为标识符
关键字：
package关键字：用于生命包
import关键字：用于导入包，一般在package之后
标识符的要求：
1、以字母、美元符号、下划线之一开始
2、首字符之后可以是以字母、美元符号、下划线或者任意数字组合
3、不能以关键字作为变量名和方法名
4、标识符大小写敏感
5、不建议使用中文或者拼音命名

关键字

运算符

Math类
很多运算，我们会使用工具类来操作
逻辑运算符

包机制

package关键字：用于生命包
import关键字：用于导入包，一般在package之后

JavaDoc生成文档

javadoc命令是用来生成自己的API文档的
参数信息

数据类型

Java是属于强类型语言，强类型语言要求变量的使用严格的符合规定，所有变量都必须定义之后使用，

java的数据类型

基本类型
数值类型：整数型、浮点数型、字符型（char占用两个字节）
Boolean类型
引用类型
类、接口、属数组

1、整型

2、浮点型

3、真值类型

4、引用类型

变量的数据转换

格式：目标类型 变量 =（目标类型）值

自动转换：小变大
强制转换：大变小

Unicode编码的字符单元

类Class的引用

可以自定义创建，也可以引用
Object，Object是一个很重要的类，
String
Date
Void:这个是一个不可实例化的占位符类,它保持一个对代表 Java 关键字 void 的 Class 对象的引用。

接口interface引用

常见的接口：集合

List

变量的作用域

变量被定义的第一个大括号就是变量的作用域

字节

拓展

类型转换

注意：

package com.company;
public class Main {
    public static void main(String[] args) {
        //操作打数的时候，注意溢出的问题
        int money = 10_000_000;
        int year = 20;
        int total = money * year;//输出存在溢出问题
        long total2 = money * ((long) money);//不存在溢出问题
    }
}

强制类型转换：高变低
自动转换：低变高

变量、常量、作用域

变量

定义：可以变化的量
java是一种强类型语言，每个变量必须声明变量类型
java变量是程序中最基本的存储单元，其要素包括变量名，变量类型，和作用域

类型：
类变量
实例变量（全局变量）
局部变量
注意：
每个变量都有类型，类型可以是基本的类型，也可以是引用类型
变量名必须合法的标识符
变量声明是一条完整的语句，因此每一个声明都必须以分号结束

package com.company;
public class Demo {
    //变量=属性
    //类变量 static,修饰不区分前后
    static final double salary = 5000;
    //实例变量：从属于对象
/*
    如果不进行初始化，数值类的默认值是0，0.0
    布尔值，默认是false
    其余都是null
*/
    String name;
    int age;
    public static void main(String[] args) {
        //局部变量必须声明和初始化，
        int i = 1;
        System.out.println(i);
        //变量类型 变量名=new Demo（）
        Demo demo = new Demo();
        //实例变量,使用实例对象来引用便变量
        System.out.println(demo.age);
        //类变量 static，可以直接使用
        System.out.println(salary);
    }
    public void add() {
    }
}

常量

一般使用大写，使用final关键字修饰
命名规范
所有变量、方法名、类名：见名知意

作用域

根据作用域

JAVA流程控制

用户交互Scanner

java.util.Scanner是Java5提供的新特性,可以通过Scanner类来获取用户的输入
基本语法

Scanner s=new Scanner(System.in);

通过Scanner类和next()与nextLine()方法获取输入字符串，
在读取前一般使用hasNext()与hasNextLine()判断是否还有输入数据
hasNext()、hasNextLine()会使得当前进行进入阻塞状态，知道输入数据

public class TestScanner01 {
    public static void main(String[] args) {
        //创建一个扫描的对象,用于接收键盘的数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用next方式接收：");
        //判断用户有没有输入字符串
        if (scanner.hasNext()) {
            //使用next()方式接收
            String str = scanner.next();
            System.out.println("输出的内容为：" + str);
        }
        //及时关闭已经完成工作的IO流
        scanner.close();
    }
}

Scanner进阶

import java.util.Scanner;
public class TestScanner02 {
    //要求输入多个数字,每个数字按回车确认,通过输入的非数字来结束输入并输出执行结果
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        //和,
        double sum = 0;
        //计算输入了多少个数字
        int m = 0;
        //通过循环判断是否还有输入,并在里面对每一次进行求和和统计
        while (scanner.hasNextDouble()) {
            double x = scanner.nextDouble();
            m = m + 1;
            sum = sum + x;
        }
        System.out.println(m + "个数的和:" + sum);
        System.out.println(m + "个数的平均值是" + (sum / m));
        scanner.close();
    }
}

顺序结构

选择结构

循环结构

break&continue

数组

创建数组的三种方式

public static void main(String[] args) {
    //创建数组的第一种方法
    int[] arr=new int[6];
    int intValue=arr[5];
    //System.out.println(intValue);
    //创建数组的第二种方法
    int[] x={1,2,3,4};
    //System.out.println(x[1]);
    //创建数组的第三种方法。
    int[] y= new int[]{1,2,3,4,5};
    int m=0;
    boolean length = isLength(m,y);
    if(length){
        System.out.println(y[m]);
    }else{
        System.err.println("数组标越界");
    }    
}
//判断数组下标是否越界
public static boolean isLength(int m,int arr[]){
    boolean flag=false;
    int length = arr.length;
    if(m<length)
        flag=true;
    return flag;
}

冒泡排序法

面向对象

面向对象（OOP）
三大特征:封装、继承、多态

集合

IO流

流的概念
定义：内存与存储设备之间传输数据的通道

流的分类
按照流向分
输入流：将<存储设备>中的内容读入<内存>中
输出流：将<内存>中的内容写入<存储设备>中

按照单位分
字节流：以字节为单位，可以读写所有数据
字符流：以字符为单位，只能读写文本数据
按功能：
节点流：具有实际传输数据的读写功能
过滤流：在节点流的基础上增强功能

字节流

字节流的父类（抽象类）：
InputStream：字节输入流
public int read(){}
public in read(byte[] b){}
public int read(byte[] b,int off,int len){}
OutputStream：字节输出流
public void write(int a){}
public void write(byte[] b){}
public void write(byte[] b,int off,int len){}

文件字节流

FileInputStream：输入流
方法：public int read(byte[] b) 从流中读取多个字节，将读到的内容存入b数组，返回实际的读到的字节数，如果达到文件尾部，则返回-1
FileOutputStream：输出流
方法：public void write(byte[] b) 一次写多个字节，将b数组中所有字节，写入输出流

import java.io.FileInputStream;
public class TestFileStream {
    public static void main(String[] args) throws Exception {
        //创建流对象,并指定文件路径
        FileInputStream fis = new FileInputStream("D:\\test.txt");
        //读取文件
        /*
        * int data = 0;
        while ((data = fis.read()) != -1) {
            //转换成字符
            System.out.print((char)data);
        }
        * 以上方法是读取出来一个转化一个,效率并不高
        * */
        //第二种方法,一次读取多个字节
        byte[] buf = new byte[1024];
        int len = 0;
        while ((len = fis.read(buf)) != -1) {
            System.out.println(new String(buf, 0, len));
        }
        /*返回读取的个数
        int count = fis.read(buf);*/
        //关闭流
        if (fis != null) {
            fis.close();
            System.out.println("执行完毕");
        }
    }
}

字符流

File类

编码方式