技术day00 ──JAVA基础

JDK的安装

配置PATH环境变量的时候为什么要使用JAVA_HOME而不直接写绝对路径？

因为在项目中可能会使用到多个jdk版本，如果每次都重新配PATH的话比较麻烦，而使用JAVA_HOME就比较方便了。

类和对象

类的定义

基于面向对象思想，现实生活中具有共同特性的对象的抽象，类由类的声明和类体组成，而类体由变量和方法组成。

类的声明

基本格式：
访问修饰符 class 类名 extends 超类名 implements 接口名
例如： public class Pen extends Stationery implements InterfaceTest

类体

类体由成员变量和成员方法组成，成员变量就是类中的一些属性，而成员方法就是这个类的对象能干什么。

例如下例：
brand、proportion、isAvailable、isReplaceable是成员属性
replace是成员方法

public class Pen {
    public String brand; //品牌
    private Integer proportion;//可用比例
    private Boolean isAvailable;//是否可用
    private Boolean isReplaceable;//笔芯是否可替换
    public void replace() {
        if (isReplaceable) {
            System.out.println("替换成功");
        } else {
            System.out.println("我不可替换");
        }
    }
}

类的实例化

java中的实例化方法有以下四种：
（1）用new 语句创建对象，这是最常用的创建对象方法。
（2）运用反射手段，调用Java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法。
（3）调用对象的clone()方法
（4）运用反序列化手段，调用java.io.ObjectInputStream对象的readObject()方法。
其中最常用的就是new的方式，所谓new 就是创建内存空间
例如：Person person = new Person(); 就创建了一个Person对象

类的继承

子类继承父类的特性和行为，使得子类对象拥有父类对象的属性和方法，同时还可以添加自己的属性和方法，由此看来，子类一般是要比父类功能强大的。

方法的重载

定义：同一个类中，有两个或者多个重名的方法，但是参数的个数、顺序、类型至少有一个不一样，就构成重载；
例如同一个类中有以下两个方法，两个方法的方法名都为write，但是参数不同，一个无参 一个有一个String类型的参数，这两个方法便构成了方法的重载。
当调用时，根据传入的参数列表，会自动匹配上相应的方法执行。

    public void write() {

        if (isAvailable) {
            System.out.println("我是一支笔，我要写字了!");
        } else {
            System.out.println("不可用!");
        }


    }

    public void write(String content) {


        if (isAvailable) {
            System.out.println("我是一支笔，我写的内容是:" + content);
        } else {
            System.out.println("不可用!");
        }

    }

方法的重写

在子类继承父类之后，自然就拥有了父类的方法，然后子类重新提供了父类的方法，就构成了方法的重写.
例如下面SonTest类中继承了CSDNTest类，然后又提供了Show(）方法，这样就重写的Show()方法。
需要注意的是，下面的main函数中，输出的内容为：

子类中的show方法
父类

父类中的show方法被子类重写，所以调用的是子类中的show方法，而属性是无法被重写的，所以输出的仍然是父类中的。

public class CSDNTest {

    public String name = "父类";

    public void Show(){
        System.out.println("父类中的show方法");
    }



    public static void main(String[] args) {
        CSDNTest csdnTest = new SonTets();
        csdnTest.Show();
        System.out.println(csdnTest.name);
        
    }
}

class SonTets extends  CSDNTest{
    public String name = "子类";
    @Override
    public void Show() {
        System.out.println("子类中的show方法");
    }
}

构造方法

构造方法就是方法名和类名一样，没有返回值类型的方法，主要是用来创建对象时初始化对象属性，例如：

public class Pen {
    public String brand; //品牌
    private Integer proportion;//可用比例
    private Boolean isAvailable;//是否可用
    private Boolean isReplaceable;//笔芯是否可替换

    public Pen(String brand, Integer proportion, Boolean isAvailable, Boolean isReplaceable) {
        this.brand = brand;
        this.proportion = proportion;
        this.isAvailable = isAvailable;
        this.isReplaceable = isReplaceable;
    }

    public Pen() {
    }
}

构造方法的调用顺序

1.先调用父类的构造器，再调用子类的构造器
2.若父类中没有对应参数的构造器，则先调用父类的无参构造器，再调用子类相应参数的构造器

方法的隐藏

子类不能重写父类的静态方法，也不能把父类不是静态的重写成静态的方法。

在子类中声明和父类相同的方法就可以将父类的静态方法隐藏

接口

接口与类的区别：
1.不能声明变量，但是可以声明常量。
2.只有方法的声明，没有方法的实现。
接口一般是一种约定，间接的实现了多继承
接口的实现也比较简单，只需要使用implements关键字实现接口，然后再实现接口中的方法即可。

常用类

数组

一个固定长度的，包含相同数据类型的数据的容器
固定长度：一旦创建，就不可以再改变长度
相同数据类型：数组中能存贮的只能是同一种数据类型
容器：用来存放数据的容器
创建方式：
int arr [ ] = new int [5] ;
int a[ ] = new int [ ] { 1,2,3,4,5 };
int [ ] x = {6,7,8,9,10};

Object类

所有类的父类，其中有两个常用方法，分别是toString和equals方法
toString方法可以返回对象的字符表达式，默认返回对象的全限定名+16进制地址，一般都会重新toString方法，来显示对象的属性值等
equals方法主要用来比较两个对象是否相等，默认是比较两个对象的地址是否相等，String类中是比较的两个字符串的内容是否相等。

String类

常用方法：
length()：返回字符串的长度
trim()：去掉字符串头和尾的空格
String(char[] value)：构造方法，可以将字符数组转换成字符串
String(String str)：构造方法，用来拷贝字符串生成一个新的字符串
indexOf(String str)：返回欲查找的字符串在被查找的字符串中的位置下标，下标从0开始，若未找到则返回-1
substring(int start,int end)：返回start到end-1的字符串 例如身份证号中的第7-14位，若使用该方法取出来则是string.substring(6,14)，可简单记为前闭后开区间

        String string = "******15780212**** ";
        System.out.println("字符串长度："+string.length());
        System.out.println("去掉空格后："+string.trim());
        System.out.println("由字符数组创建字符串："+new String(new char[]{'h','i'}));
        System.out.println("拷贝字符串："+new String(string));
        System.out.println("数字9首次出现的位置："+string.indexOf('9'));
        System.out.println("是否和变量str相同："+str.equals(string));
        System.out.println("生日："+string.substring(6,14));

String、StringBuffer、StringBuilder的区别

String是一个不可变的字符序列，当创建完成之后就不能再改变了，再发生字符串拼接之类的操作的时候只能创建一个新的String，而原先的不变，如果操作的较多的时候就会有很多对象存储在内存中，造成资源浪费
StringBuffer是可变的字符序列，对他进行拼接操作的时候只需要调用append方法即可，是线程安全的，但是效率低
StringBuilder同StringBuffer基本一致，只不过是线程不安全的
使用场景：
不经常变的使用String
经常变的且多线程情况下使用StringBuffer
经常变的且单线程情况下使用StringBuilder

包装类

基本数据类型和包装类之间的转换

基本数据类型到包装类：使用包装类的valueOf方法和自动装箱两种

        int i = 999;
        Integer anInt = i;
        Integer integer1 = Integer.valueOf(i);

包装类到基本数据类型：自动拆箱和xxxValue方法

        int  b = anInt;
        int i2 = integer1.intValue();

基本数据类型和字符串之间的转换

基本数据类型到字符串：使用String的valueOf方法或者加一个字符串

        String s = String.valueOf(i1);
        String s1 = "" + i1;

字符串到基本数据类型：使用parseXXX方法

        int i1 = Integer.parseInt("123");

包装类和字符串之间的转换

包装类到字符串之间的转换：使用toString方法

 String string = anInt.toString();

字符串到包装类，使用包装类的valueOf方法

 Integer integer = Integer.valueOf(string);

容器类

colletion：能放单一元素的容器，包含Set和List
map：以键值对的形式进行存储，其中键不可重复
HashSet：不可重复、无序、最多只有一个null
Vector：基于数组，同步、线程安全、执行效率较低，比较古老的实现类
ArrayList：基于数组，不同步、线程不安全，修改和查询效率比较高，在需要快速随机访问的时候使用
LinkedList：基于双向链表，允许null，增加、删除效率比较高，插入删除操作比较多的时候使用
HashMap：key不能重复，线程不安全、效率高，null可以为key，不过只能有一个null
Hashtable：key不能重复，线程安全、效率高、key和value均不能为null

IO流

分类：按照流的方向来分：分为输入流、输出流 (这里的输入、输出均是针对程序本身来说的)
按照处理单元来分：分为字符流和字节流
按功能不同来分：分为节点流和处理流
节点流：以从或向一个特定的地方（节点）读写数据。如FileInputStream　
处理流：是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。如BufferedReader。处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装。
文件操作中的常用方法：

        File f = new File("D:/test.txt");
        //判断文件是否存在
        boolean exists = f.exists();
        //判断是否是文件夹
        boolean directory = f.isDirectory();
        //判断是是否是文件
        boolean file = f.isFile();
//        获取文件的长度
        long length = f.length();

        //获取最后修改时间
        long l = f.lastModified();
        Date date = new Date(l);
        //文件重命名
        File file1 = new File("D:test1.txt");
        f.renameTo(file1);
        //删除文件
        f.delete();

异常

异常是指程序中某些地方出错误时创建的一种特殊的运行时错误对象，程序捕捉到以后可以进行相应的处理。
异常的基类是Throwable，下面有两个子类，分别是Error和Exception
cahth异常的时候要把影响小的放在最前面，影响大的放在后面
常见的运行时异常：
NullPointerException - 空指针引用异常
ClassCastException - 类型强制转换异常。
IllegalArgumentException - 传递非法参数异常。
ArithmeticException - 算术运算异常
ArrayStoreException - 向数组中存放与声明类型不兼容对象异常
IndexOutOfBoundsException - 下标越界异常
NegativeArraySizeException - 创建一个大小为负数的数组错误异常
NumberFormatException - 数字格式异常
SecurityException - 安全异常
UnsupportedOperationException - 不支持的操作异常