培训

什么是JRE

java程序只有JVM不能直接运行，还需要核心类库，才能保证java的运行，所以java平台提供了一个运行时的环境JRE

它包含了Java虚拟机和Java程序所需的核心类库等，如果想要运行一个开发好的Java程序，计算机只需要安装JRE即可，JRE是Java程序中的充要条件。JRE = JVM + 类库

JVM

JVM是Java虚拟机，java程序需要运行在虚拟机上，不同平台有各自的虚拟机，它是Java语言可以跨平台的凭借。但如果只有JVM，还不足以运行java程序，是Java程序运行的一个必要条件。

什么是JDK

Java平台提供了一个给java开发人员使用的，其中包含了JRE和java开发工具的开发环境，他就是JDK

,即Java开发工具包。由于JDK包含JRE，因此我们只需要安装JDK就都有了。JDK = JRE + JAVA的开发工具

 

编译语言和解释型语言：需通过编译器将源代码编译成机器码，之后才能执行的语言。一般需经过编译、链接这两个步骤。编译十八源代码编译成机器码，链接是把各个模块的机器码和依赖库串联起来生成可执行文件。

优点：编译器一般会有预编译的过程对代码进行优化。因为编译只做一次，运行时不需要编译，所以编译型语言的程序执行效率搞。可以脱离语言环境独立运行。

缺点：编译之后如果需要修改就需要整个模块重新编译。编译的时候根据对应的运行环境生成机器码，不同的操作系统之间移植就会有问题，需要根据运行的操作系统环境编译不同的可执行文件。

代表语言：C、C++、Pascal、Object-C以及很火的苹果新语言swift

解释型语言

解释型语言的程序不需要编译，相比编译型语言生了道工序，解释性语言在运行程序的时候才逐行翻译

优点：有良好的平台兼容性，在任何环境中都可以运行，前提是安装了解释器（虚拟机）。灵活，修改代码的时候直接修改就可以，可以快速部署，不同停机维护。

缺点：每次运行都需要解释一遍，性能上不如编译型语言。

代表语言：JavaScript、Python、Erlang、PHP、Perl、Ruby

混合型语言

Java源代码在编译的时候不是直接编译成机器码而是中间码（java环境下称为字节码），然后再由java平台再提供的JVM来解释执行。

严格的来说混合型语言属于解释型语言，Java更接近与解释型语言

程序执行过程

 

隐式数据类型转换

取值范围小的数据类型与取值范围大的数据类型进行运算，会将小的数据类型提升为大的，再运算：

 

eclipse中新建Java工程的三个JRE选项区别

https://blog.csdn.net/wdjhzw/article/details/42086615

 

 

数组的内存分配：

JVM内存划分：

java程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

栈：存储局部变量

堆：存储new出来的东西

 

方法：

修饰符 返回值类型 方法名（参数类型 参数名1，参数类型 参数名2......){

                  方法体；

                 return  返回值；

}

修饰符： public static / private

返回值类型：限定返回值的数据类型

方法名：方法的名字

参数类型：接受调用方法时传入的数据类型

参数名 用于接收调用方法时传入的数据的变量

方法体：完成功能的代码

return：返回值

 

面向对象

https://www.yuque.com/wudangniu/ql6z2g/ystrf4#9VWKT

规范：

getObejct（）：  有返回值return，无参

setObject（）： 无返回值，有参

 

API概述和字符串类

API(Application Programming Interface) : 应用程序编程接口

Java API指的就是JDK中提供的各种功能的Java类

replacement()-- 用来替换第一个匹配的字符串

String常用API方法

equals ----------------判断字符串是否相等

equalsIgnoreCase()---------判断字符串内容是否相同，忽略大小写

startsWith(String str)----------判断字符串对象是否以指定的str开头  

endWith(String str)------------判断字符串对象是否以指定的str结尾

length--------------获取字符串长度

charAt(int indext)--------------获取指定索引处的字符

indexOf（String str)-------------获取str在字符串对象中第一次出现的索引

substring-------------

toCharArray----------把字符串转换为字符数组

toLowerCase--------把字符串转换为小写字符串

toUpperCase----------把字符串转换为大写字符串

trim----------- 去除字符中的空格

split------------- 把字符串分割成一个字符串数组

StringBuilder常用API方法

StringBuilder:是一个可变的字符串。字符串缓冲区类

String的内容是固定的

StringBuilder的内容是可变的

length------------获取字符串长度

append(任意类型)------------ 添加数据，并返回自身对象

reverse------------  反转

toString-------------- 将当前StringBuilder对象 转换成String对象

insert（int offset, Object obj)--------------- offset ----偏移量,offset必须大于等于0，小于该序列的长度   

 

ArrayList的常用API方法

java 对事物的描述是通过对象来描述的

对象拥有多个属性

为了方便对多个对象进行操作， 就应该是一个容器类型的变量

add(Object o)----------增加元素

add(index,Object o)-----------指定位置插入元素

size()------------返回集合中的元素个数

get(int index)-----------返回指定索引出的元素

remove(Object o)---------删除指定元素，返回删除是否成功

remove (int index)-------------删除指定索引处的元素，返回被删除的元素

set(int index,E element):修改指定索引处的元素，返回替换的元素 (element 为替换的元素)

 

 

IO流基础知识：

• IO流用来处理设备之间的数据传输
• Java对数据的操作是通过流的方式
•  Java用于操作流的类都在IO包中
• 流按流向分为两种：输入流，输出流

FileWriter类的使用：（写出）

构造方法：FileWriter(String fileName) 传入一个文件的路径

成员方法：

write(String str) -----------向文件中写str

flush()  ------------ 将内存中的数据刷新到文件中

close()-----------关流，释放底层资源

 

FileReader类的使用：（读入）

构造方法：FileReader(String fileName) 传入一个文件的路径

成员方法：

FileReader fr = new FileReader("FileWriterDemo.java")

read()---------------读取单个字符

read(char[] cbuf) --------------读取字符，并将字符读入数组

 

缓冲流的基本使用：

BufferedWriter、BufferedReader的基本使用：

BufferedWriter:将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入

创建输出缓冲流对象：

BufferedWriter bw = new BufferedWriter(new FileWriter  ("Copy.java"));

BufferedReader:从字符输入流中读取文本，缓冲各个字符，聪哥实现字符、数组和行的高效读取

创建输入缓冲流对象：

BufferRead br = new  BufferRead(new FileReader ("FileWriterDemo.java"));

 //一次读写一个字符
        int ch;
        while((ch=br.read())!=-1){
            System.out.print((char)ch);
        }
        */
        
        //一次读写一个字符数组
        char[] chs = new char[1024];
        int len;
        while((len=br.read(chs))!=-1) {
            System.out.print(new String(chs,0,len));
        }

缓冲区的特殊功能：

BufferedWriter：       void newLine()------------------------ 写一个换行符，这个换行符由系统决定

BufferedReader:         String readLine()---------------------- 一次读取一行数据，但是不读取换行符

 

 

静态使用方法及加载原理

被static修饰的成员可以并且建议通过类名直接访问。

也可以通过某个对象访到属于类的静态成员，原因即多个对象均属于一个类，共享使用同一个静态成员。

ublic class Chinese {
    //静态成员,被多个对象共享
    /**  
    * @Fields country : 国籍  
    */  
    public static String country = "中国";
    //普通成员,每个对象的普通成员其内容不同
    /**  
    * @Fields name : 姓名  
    */  
    private String name;
    /**  
    * @Fields age : 年龄  
    */  
    private int age;
    /**  
    * @Fields work : 职业  
    */  
    private String work;

    /**  
    * @Title: Chinese      
    */
    public Chinese() {
        super();
    }

    /**  
    * @Title: Chinese  
    * @param name
    * @param age
    * @param work    
    */
    public Chinese(String name, int age, String work) {
        super();
        this.name = name;
        this.age = age;
        this.work = work;
    }

    /**
     * @return the name
     */
    public String getName() {
        return name;
    }

    /**
     * @param name the name to set
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * @return the age
     */
    public int getAge() {
        return age;
    }

    /**
     * @param age the age to set
     */
    public void setAge(int age) {
        this.age = age;
    }

    /**
     * @return the work
     */
    public String getWork() {
        return work;
    }

    /**
     * @param work the work to set
     */
    public void setWork(String work) {
        this.work = work;
    }

}

 

public class StaticDemo {
    public static void main(String[] args) {
        //创建人类对象,验证静态static修饰的成员被多个对象共享
        Chinese c = new Chinese("王宝强", 34, "演员");
        System.out.println(c.getAge()+"岁的"+c.getName()+"是"+c.country+"人");
        
        Chinese c2 = new Chinese("周星驰", 48, "演员或导演或制片");
        System.out.println(c2.getAge()+"岁的"+c2.getName()+"是"+c2.country+"人");
        
        c.country = "中华人名共和国";
        System.out.println("================================");
        
        System.out.println(c.getAge()+"岁的"+c.getName()+"是"+c.country+"人");
        
        System.out.println(c2.getAge()+"岁的"+c2.getName()+"是"+c2.country+"人");

    }
}

 

继承

继承的目的是为了减少重复代码

特点：

Java支持单继承

Java支持多层继承

父类定义了继承树中共性内容，子类定义了该类个性内容。

在结合多态后，能使用父类时尽量使用父类，提高程序扩展性。

 

重写

子类继承父类之后，可以直接调用父类的非私有方法。如果子类认为父类的非私有方法不够强大，子类可以按照自身逻辑重新定义继承的父类方法。重新定义继承的父类的方法的过程叫重写。

子类重写方法之后不能再调用父类中的该方法

注意事项：

1. 方法签名必须相同（方法签名——方法名+参数）
2. 访问权限必须相同，或者子类的访问权限更大（访问权限顺序：public > 默认）
3. 访问权限一般必须相同（不适用于所有情况）

方法重写后，调用该方法时不再调用父类的方法，而调用子类重写后的方法。

代码体现在子类的构造方法调用时，一定先调用父类的构造方法。

 

 

this与super访问普通成员

调用普通成员：

• this.成员变量       可以访问本类对象的成员变量
• super.成员变量     可以访问父类的成员变量
• this.成员方法()     可以访问本类对象的成员方法
• super.成员方法()    可以访问父类的成员方法

子类方法中

• 访问子类自身的成员用this.
• 访问父类的成员super.

就近原则:

• 局部  > 本类成员  > 父类成员