java常用类，接口，方法，语法总结

都是自己平常总结的，这一篇手打了一万字的，希望对大家有用，后面会持续更新JavaSE笔记总结，会把它们放在一个专题中，更新完后，还会有JavaWEB总结，框架总结等，建议收藏~

#Java常用类，方法，接口，语法汇总
1、首先了解几个关键词语
    JVM：Java虚拟机
    JRE:jave运行环境，包含Java虚拟机和Java核心类库
    JDK:Java开发工具，包含JRE和开发工具

2、Java关键字全部小写，例如：public，class，static

3、Java是一种强类型语言，在Java中数据类型包含基本数据类型和引用数据类型
    基本数据类型：整数类型int，byte，short，long（使用时之后面加上L）。浮点型flort（使用时后面加上F），double 字符类型char 布尔类型boolean

4、标识符：
    Java中标识符就是我给类，变量，方法，常量起的名字，着些名字中一些命名规则
    类，接口命名：所有单词首字母都大写
    方法，变量，常量命名：除第一个单词首字母小写，其余首字母都大写

5、切记“=”这个是赋值，“==”这个是等于判断符号

6、逻辑运算符&有与的作用，&&也有与的作用，但是后者有短路的作用，判断第一个不符合不往后进行判断，“|“和”||"同理

7、Scanner类：Java中键盘数据输入一般要使用的一个类，具体有待探究
    构造方法：Scanner sc = new Scanner（System.in）；
    一般方法：int nextInt（）；接受键盘录入的int数据
         String nextLine();接受键盘输入的String类型的数据

8、水仙花数：一个三位数字，个位十位百位的数字立方和等于原数字（153  1*1*1+5*5*5+3*3*3=153）

9、Random类：java中产生随机数功能的类
    构造方法：Random r=new Random（）；
    一般方法：int nextInt​(int bound)；产生随机数在0-bound之间

10、数组概念：数组就是一种存储数据长度固定的容器，存储多个数据的数据类型一样

11、数组的定义及初始化：
    数据类型[] 数组名=new 数据类型[数组长度]；
    例如：int[] arr=new int[1024];
          byte[] bys=new byte[1024];
    数据类型[] 数组名=new 数据类型[]{元素.....};
    例如：int[] arr=new int[]{1,2,3,4};

12、数组里数组长度可用arr.length

13、什么是方法：方法是将具有独立功能的代码块组成一个整体，使其具有特殊功能的代码集合。

14、方法的定义格式：
    public static 返回值类型 方法名（形式参数）{
    //方法体
    }

15、方法要注意的事项：
    1方法不能嵌套定义
    2void表示无返回值，可以不用加return，如果想加上，return后面不加数据

16定义方法时要注意两个明确：
    1明确返回值类型，如果没有写void
    2明确参数的类型和数量

17、方法重载就是在同一个类中，定义的方法之间的关系。

18、方法重载应满足的条件：
    1在同一个类中
    2具有相同的方法名
    3具有的参数不同，类型或者数量

19、方法重载注意点：
    1只与定义有关，与调用无关
    2只针对方法参数的类型或数量，与方法的返回值无关

20、客观存在的事务都为对象，可以说万物皆对象

21、类的定义格式
    public class 类名{
        //成员变量
        变量1的数据类型 变量1；
        变量2的数据类型 变量2；
        ...
        //成员方法
        方法1
        方法2
    }

22、对象的使用
    创建对象的格式：类名 对象名=new 类名（）；
    调用成员的格式：对象名.成员变量； 对象名.成员方法（）；

23、成员变量存储在堆内存中，new开辟堆内存的存储空间，用来存放成员变量。而成员方法存储在栈内存中，此类的所有对象共同使用同一成员方法，而不同对象使用的成员变量确实各自的。

24、还有一种情况
    Student s1=new Student();
    Student s2=s1;
    这种情况是什么意思：s1开辟了一份自己独有存储成员变量的空间，这个时候又把s1开辟存储的空间地址共享给了s2，让s2也指向了s1的地址，这种情况下，s1与s2就有共同且相同的空间用来存储成员变量

25、成员变量与局部变量的区别：
    1成员变量在类中方法外，而局部变量在类中方法内
    2存储位置不同，成员变量存储在堆内存，只要创建的对象存在，它就会一直存在。局部变量存储在栈内存中，方法调用完以后就会消失。
    3成员变量一般存在与没有main()方法的类中，且成员变量有默认初始值，而局部变量没有默认初始值，必须先定义，赋值后才能使用。

26、封装
    1private关键字的使用：private是一个修饰符，用来修饰成员，被private修饰的成员，只能在本类中进行访问，针对Private修饰的成员变量，如果需要被其他类使用，提供想要的操作get（类型 类型名），set（）。
    2this关键字：this也是修饰符，代之成员变量，其主要作用是区分局部变量和成员变量的区别
    3封装思想：封装是面向对象三大特征之一，是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的。
    4封装原则：将某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类内部提供的方法来实现对隐藏信息的操作和访问
    5封装好处：通过方法来控制变量，提高了代码的安全性，把代码用方法进行封装，提高了代码的复用性
27、构造方法：是一种特殊的方法
    作用：创建对象使用的方法 Student s = new Student();
    格式：public 类名（）{}
          public 类名（参数）{方法体}
    功能：完成对象数据的初始化
    建议：如果定义一个类以后需要实例化，那建议无论是否使用无参或带参构造，这两种构造方法全部写上
28、API
    1什么是API：一般情况下，API指的是应用程序编程接口。Java中的API指的是JDK中提供的各种功能的Java类，这些类将底层的实现封装了起来。
29、String类
    1概述：Java中所有带双引号""的字符串，都是String类的对象，处于Java.lang包下，不需要导包
    2特点：
        字符串不可变，它的值在创建后不可更改，后面有StringBuilder类，这个类提供的可变的类
        虽然String的值是不可变，但是它们可以被共享
        字符串效果上相当于字符数组char[],但是底层实现确实字节数组byte[]
    3String类的构造方法
        public String（）
        public String（char[] chs)
        public String(byte[] bys)
        String s = "abc"
    4创建字符串对象的两种区别
        通过new创建的字符串对象，每一次new都会申请一个内存空间，虽然内容相同，但是地址值不同
        以""方式给出的字符串，只要字符序列相同（顺序和大小写），无论在程序代码中出现几次，JVM都只会建立一个String对象，并在字符串池中维持
    5String类常用的方法
        boolean equals​(Object anObject) ：比较字符串与指定对象内容是否相同，区分大小写，用法"abc".equals(String s)
        char charAt(int index)：返回指定索引的char值
        int compareTo​(String anotherString) :按照字典的顺序比较两个字符串，排序用
        byte[] getBytes​()：将String编码为字节数组的形式
        int length​()：返回此字符串的长度 

30、StringBuilder类
    1.概述：StringBuilder类是一个可变的字符串类，可以把它看成一个容器，可变指的是StringBuilder类实例化的对象中内容是可变的
    2.StringBuilder类构造方法
        public StringBuilder​()构造一个没有字符的字符串对象，初始容量为16个字符。
        public StringBuilder(String str)根据字符串的内容，来创建可变的字符串对象
    3.常用方法
        public StringBuilder append(任意类型)添加数据，返回对象本身
        public StringBuilder reverse()返回相反的字符串序列
        public int length()返回长度
        public String toString()将StringBuilder转换成String
    4.StringBuilder和String相互转化
        StringBuilder->String：StringBuilder类提供toString()方法
        String->StringBuilder:在StringBuilder类的构造方法的时候使用public StringBuilder(String str),就可以了

31、ArrayList集合
    1.集合就是提供了一种存储空间可变的存储模型，存储的数据容量可以发生变化
    2.构造方法：
        public ArrayList<T>()创建一个空的集合对象
    3.常用方法：
        public void add​(int index, E element)：在集合指定位置插入指定元素 
        public boolean add​(E e)：在集合末尾添加一个元素，返回是否添加成功
        public int size()：返回集合中 的元素个数
        public E get(int index):返回集合中指定位置的元素
        public E set(int index,Eelement):修改指定位置的元素，返回被修改的元素本身
        public E remove(int index):删除指定索引处的元素，返回被删除的元素
        public boolean remove(Object o)：删除指定的元素，返回删除是否成功
    4.要点：集合中不能存储基本数据类型，存基本数据类型的时候，会自动类型转换，存储进集合的都是空间地址，无论是添加元素、删除元素、修改元素、获取元素，全部用到的都是空间地址
    例如：
        ArrayList<Student> array=new ArrayList<Student>();
        Student s1 = new Student(...);
        Student s2 = new Student(...);
        array.add(s1);//这里添加的都是Student对象的地址
        array.add(s2);
        Student s=array.get(0);//这里获取的是索引为0的元素，而这个元素就是Student类实例化的对象地址，因此对象s被s1的地址赋值，可以理解为s等同于s1，类实例化对象成功在于是否指向一个空间地址，或者构造方法new一个空间地址，或者直接赋值一个地址
        system.out.println(s.getName+","+s.getAge);//既然s等同于s1，即两者相等

32、继承
    1.概念：继承是面向对象的三大特征之一，可以让子类具有父类的属性和方法，还可以在子类中重新定义(方法重写），以及追加属性和方法
    2.继承带来的用处：继承可以让类与类之间产生关系，子父类的关系，产生子父类后，子类则可以使用父类中非私有的成员
    3.继承的好处
        提高代码的复用性（多个类相同的成员可以放在同一个类中）
        提高了代码的维护性（如果方法的代码需要修改，修改一处即可）
    4.继承的弊端
        继承让类与类之间产生关系，类的耦合性增强了，当父类发生变化时，子类不得不随着变化，削弱了子类的独立性
    5.变量的访问特点
        先子类局部找，再子类全局找，再父类成员找，都没有就报错
      构造方法的访问特点
        子类中所有的构造方法默认都会访问父类的无参构造方法，如果父类中没有无参构造方法，只有带参构造方法，那要么在子类构造方法通过super关键字调用父类带参构造方法，要么在父类中写上无参构造方法，建议在父类中写入
    6.super关键字：可以理解成父类对象的引用
        super.成员变量:访问父类成员变量
        super.成员方法：访问父类成员方法
        super(...)：访问父类构造方法
    7.方法重写：子类出现和父类一模一样的方法声明(方法名相同，参数列表也必须相同)
    8.方法重写作用：当子类需要父类的功能，又想要自己特有的功能的时候可以使用方法重写（在子类重写的方法中可以用super关键字来使用父类方法，重写的方法体就是子类特有功能）
    9.方法重写注意事项：父类私有方法不能重写（父类私有成员子类不能继承） 子类重写的方法访问权限只能是public、protected、默认 Java中继承只支持单继承和多层继承
    10.package 包
        概述：包其实就是文件夹，用来管理文件的
    11.import 导包
        概述：使用不同包下的类时，使用的时候要写类的全路径，写起来太麻烦了，于是就提供了导包的功能
        如果没有导包
            Java.util.Scanner sc=new java,util.Scanner(System.in);
        如果导包过后
            Scanner sc=new Scanner(System.in);
    12.final
        概述：final代表最终的意思，可以修饰成员方法，变量，类
        修饰类：该类不能被继承，就是不能有子类可以有父类
        修饰成员方法：该方法不能被重写
        修饰变量：表明该变量是一个常量，不能被继续赋值
    13.final修饰的局部变量时，修饰基本数据变量时，数据值不能改变。修饰引用类型变量时，地址值不可改变，但地址空间内的内容可以发生改变。
    14.static关键字
        static关键字是静态的意思，可以修饰成员方法，成员变量
        特点：被类的所有对象共享，这是判断是否使用的条件。可以通过类名调用，也可以通过对象名调用（推荐使用类名调用）
    15.非静态成员方法既可以访问静态成员也可访问非静态成员，而静态成员方法，只能访问静态成员

33、多态
    1.概述：同一个对象，在不同时刻表现出来的不同形态
    2.多态前提：要有继承或实现关系 要有方法重写 要有父类引用指向子类对象
    3.多态中成员访问特点
        成员变量：编译看父类，运行看父类
        成员方法：编译看父类，运行看子类
    4.好处：提高程序扩展性  弊端：不能使用子类的特有方法
    
34、抽象类 public abstract 类名（）{}
    1.概述：在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。 
抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。
由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。
父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。
在 Java 中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。
抽象类如何实例化：通过多态的方式，通过子类对象实例化，叫做抽象类多态
    2.抽象类的子类：要么是抽象类，要么重写抽象类中的抽象方法

35、接口 public interface 类名（）{}
    1.概述：在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。
接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。
接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。     
    2.特性：接口不能用于实例化对象。接口没有构造方法。接口中所有的方法必须是抽象方法，Java 8 之后接口中可以使用 default关键字修饰的非抽象方法。接口不能包含成员变量，除了 static 和 final 变量。接口不是被类继承了，而是要被类实现。接口支持多继承
    3.接口中没有变量，所有的成员变量前面默认public static final修饰。接口中只有抽象方法，所有方法前面默认public abstract
（JDK9以后接口也有默认方法default、静态方法和私有方法）
    4.类与接口的关系
        类与类之间：继承关系，只能单继承，可以多层继承
        类与接口之间：实现关系，可以单实现，也可以多实现。也可以在继承一个类以后实现多个接口
        接口与接口之间：继承关系，可以单继承，也可以多继承
    5.抽象类与接口的关系
        成员区别：抽象类有常量，变量，构造方法，抽象方法和非抽象方法。接口中有常量和抽象方法
        关系区别：类与类继承，单继承。类与接口实现，多实现。接口与接口继承，多继承。

36、参数和返回值
    1.类名作为参数和返回值
        类名作为方法的形参：实际是传递的是该类的对象的地址值
        类名作为方法的返回值：实际传递的也是该类对象的地址值
    2.抽象类作为参数和返回值
        抽象类作为方法的形参：实际传递的是该抽象类子类对象的地址值
        抽象类作为方法的返回值：实际传递的是该抽象类子类对象的地址值
    3接口名作为参数和返回值
        接口名作为方法的参数：实际传递的是该接口实现类对象的地址值
        接口名作为方法发返回值：实际传递的是该接口实现类对象的地址值

37、内部类
    1.概念：在一个类中定义一个类
    2.格式
        public class Outer{
            public class Inner{
        
            }
        }
    3.内部类特点：内部类可以直接访问外部类的成员，包括私有。外部类要访问内部类必须先创建对象。

38、成员内部类
    1.概念：就是在类中和成员变量在一个位置的内部类
    2.在外界创建成员内部类格式
        Outer.Inner oi = new Outer().new Inner();
    3.将一个类设计成内部类目的是不想让外部去访问，所以定义内部类应该私有化，然后再提供一个外界调用的方法，方法内部创建内部类对象并调用
    public class Outer{
        private int num = 10;
        private class Inner{
            public void show(){
                system.out.println(num);
            }
        }
        public void method(){
            Inner i = new Inner();
            i.show();
        }
    }
39、局部内部类
    1.位置：在方法中定义的类
    2.局部内部类外界无法直接访问，需要在方法内部创建对象并使用。局部内部类可以直接访问外部类的成员，也可以访问方法的局部变量

40、匿名内部类
    1.前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类
    2.匿名内部类格式：new 类名(){重写方法} new 接口名(){重写方法}
    new Inter(){
        @Override
        public void method(){}
    }
    3.本质：是一个继承了该类或者实现了该接口的子类匿名对象，其实也可以把他当成实现类或者子类对象

41、Math类
    1.概述：Math 包括执行基本数字运算的方法
    2.Math类无构造方法，但内部的方法都是静态的，可以通过类名直接调用
    3.常用方法
        public static E abs(E a) 返回参数的绝对值
        
42、System类
    1.常用方法：
        public static void exit(int status)终止当前运行的Java虚拟机，非零表示异常终止
        public static long currentTimeMillis()返回当前时间（单位是毫秒）
    Arrays类
        常用方法：public static void sort(int[] a):按照数字顺序排序指定数组

43、Object类的toString equals方法
    1.Object是类层次结构的根，每个类都可以将Object作为超类。所有类都直接或间接继承该类，换句话说，该类所具有的方法，所有类都有一份
    2.toString方法的作用
        以良好的格式，更方便的展示对象中的属性值
    3.equals方法的作用
        用于对象间的比较，返回true和false的结果
        例如：String s1 = "123";
            String s2 = "123";
            if(s1==s2){
                system.out.println("比较的是对象地址);
            }else if(s1.equals(s2)){
                system.out.println("比较的是字符串的内容");
            {

44、包装类
    1.基本类型包装类
        byte->Byte int->Integer char->Character.....
    2.Integer类
        *概述：包装一个对象中原始类型int的值，该类还提供了几种将int转换为String和String转换为int ，以及其他常量和方法在处理int时非常有用
        *构造方法：
            public Integer(int value):根据int值创建Integer对象
            public Integer(String s):根据String值创建Integer对象
            public static Integer valueOf(int i):返回表示指定的int值的Integer实例
            public static Integer valueOf(String s):返回表示指定的String值的Integer实例
        *int和String类型的相互转换
          int->String
            直接在数字后加一个字符串
             int num = 100;
             String s = num+"";
            通过String类静态方法valueOf()
             int num = 100;
             String s = String.valueOf(num);
          String->int
            先将字符串转成Integer，在调用intValue()
             String s ="100";
             Integer i = Integer.valueOf(s);
             int x = i.intvalue();
            通过Integer静态方法parseInt()
             String s = "100";
             int i = Integer.parseInt(s);
    3.Data类
        *概述：代表一个特定的时间，精确到毫秒
        *构造方法：
            public Date():分配一个data对象，并初始化，代表它被分配的时间
            public Date(long date)：分配一个data对象，并将其初始化为表示从标准基准时间起指定的毫秒数
        *常用方法：
            public long getTime():获取的时期对象是从1970年1月1日00：00：00到现在的毫秒数
            public void setTime(long time):设置时间，给到的是毫秒值
    4.SimpleDateFormat类
        *概述:用于格式化日期，和解析日期
        *构造方法：
            public SimpleDateFormat():构造一个SimpleDateFormat，使用默认模式和日期格式
            public SimPleDateFormat(String pattern):构造一个SimpleDateFormat，使用给定模式和默认的日期格式
        *常用方法：
            public final String format(Date date):将日期格式化成日期/时间字符串
            public Date parse(String source):从给定字符串开始解析文本生成日期
    5.Calendar类
        *概述：为特定瞬间与一组日历字段之间转换提供了一些方法，并为操作日历字段提供了一些方法。calendar提供了一个类方法getlnstance，用于获取这种类型的一般有用的对象。该方法返回一个Calendar对象，日历字段使用当前日期初始化：Calendar rightnow=Calendar.getlnstence();
        *常用方法：
            public int get(int field):返回给定日历字段的值
            public abstract void add(int field,int amount):根据日历的规则，将指定的时间添加或减去给定的日历字段
            public final void set(int year,int month,int date):设置当前日历的年月日

45、异常
    1.概述：异常就是程序出现了不正常的情况
    2.异常的体系结构Throwable->(Error,Exception)->(RuntimeException,非RuntimeException)
    Error:严重错误，不需要处理
    Exception:异常类，可以修改的错误
    RuntimeException:运行时错误，编译期不检查，出现问题回来改代码
    非RuntimeException:编译时错误，编译期必须改正，否则代码无法运行
    3.JVM默认处理异常的方法：把程序异常的名称，错误原因及异常出现的位置等信息在控制台输出，程序停止执行
    4.异常处理方式
     *try-catch方式
        try{
            可能出现异常的代码；
        }catch(异常类名 变量名){
            异常处理代码；
        }
     *throws方式
        public void 方法() throws 异常类名{}
        *throws格式是跟在方法的括号后面的
        *如果采用throws方案，将来谁调用谁处理，运行时异常可以不处理，出现问题后，需要回来改代码
    5.Throwable成员方法：
        public String getMessage():返回throwable的详细消息字符串    
        public String toString():返回此可抛出的简短描述
        public void printStackTrace():把异常的错误信息输出在控制台
    6.throws和throw的区别
        *throws
        用在方法声明后面，跟的是异常类名
        表示抛出异常，由调用它的方法来处理
        表示出现异常的一种可能性，并不一定会出现
        *throw
        用在方法内，跟的是异常对象名
        表示抛出异常，由方法体内的语句处理
        执行throw一定抛出了某种异常
        *格式：throw new 类名(...);