JAVA

简介

1. 面向对象的特征主要有哪些：

   • 封装

   • 继承

   • 多态

   • 抽象

2. 输入，输出

   1. 输出：System.out.println("Hello");

   2. 输入：

   
   //在Java中的输入需要使用Scanner的对象读取来自System.in的输入，Scanner类在包java.util中，使用时须导入：
   
   import java.util.Scanner;
   
   Scanner对象中常用的获取用户输入的方法有：
   
       String nextLine();
   
       boolean nextBoolean();
   
       short nextShort();
   
       int nextInt();
   
       long nextLong();
   
       double nextDouble();
   
   
   
       Scanner input = new Scanner(System.in);
   
       System.out.print("请输入圆的半径");
   
       double radius = input.nextDouble();
   
       double area = radius*radius*3.14;
   
       System.out.println("圆的面积是："+area);
   

3. 标识符的组成：

   1. Java标识符由：字母，数字，下划线，美元符号$组成，并且只能以字符，下划线，$开头。

   2. 标识符是大小写敏感的并且未规定最大长度

   3. 标识符不能是Java关键字或者保留字

4. 数据类型：程序设计语言描述事物，对象的方法。Java数据类型分为基本类型和引用类型两大类。

   1. 基本类型

      • 整数类型：byte，short，int，long

      • 浮点类型：float，double

      • 字符类型：char

      • 布尔类型：boolean

   2. 引用类型：

      • 类

      • 接口

      • 数组

      • 枚举

   3. Java是一种强类型语言。这就意味着必须为每一个变量声明一个类型。在java中，一共有8种基本类型：4种整数类型，2种浮点类型，1种字符类型，一种布尔类型。

      • byte：1字节

      • short：2个字节

      • int：4个字节

      • long：8个字节

      • char：2个字节

      • boolean：1个字节

      • float：4个字节

      • double：8个字节

      • （默认10000000表示-128）

5. 常量的定义：
   final int NUM = 12; //常量一旦被初始化，就不能再改变值1. java种支持的运算符
   1. 类型转换：

   1. 隐式转换：int n = 5;double f = n;

   2. 强制转换：double f = 5.5;int n = (int )f;

   3. 数据类型按容量大小排序：byte--short--char--int--long--float--double

数组

1. 数组的初始化：数组只是声明的话，JVM并没有给数组分配内存空间，在使用数组前还需要对其进行初始化（即为其分配内存空间）。给数组元素分配内存并未数组元素赋初始值的过程称为数组初始化。

2. 静态初始化
   int ids[] = {1,2,3}1. 动态初始化
   int ids[] = new int[4]; for(int i = 0;i<3;i++){ ids[i]=i; }1. 数组的使用
   int i = ids[0];1. 二维数组

   1. 声明：

   ```

   1.int[][] ids;

   2.int [] ids[];

   3.int ids[][];

   ```1. 初始化

   1. 静态初始化

   ```

   int num [][] = {{1,2},{3,4}};

   ```1. 动态初始化

   
   String[][] names = new Stirng[3][4];
   

3. Arrays类的引入

   1. 常用方法

   ```

   1.copyOf：实现数组的赋值

   2.fill：可以为数组填充相同的值

   Arrays.fill(names,"Hello!");

   3.sort：实现数组的排序

   Arrays.sort(names);
   
   Arrays.sort(names,0,3); //对第一个到第四个进行排序

   4.binarySearch：实现排序后的数组元素查找

   5.copyOfRange();

   int[] b = Arrays.copyOfRange();

   ```1. 初始化

   
   List<String> str = new ArrayList<>();
   
   str.add("Hello!");
   

   类和对象

   1. 封装：将属性（数据）和处理这些属性的行为结合起来，仅对外公开接口以达到信息隐藏的目的。

   2. 继承：在软件开发种，若已有类A，要创建类B，而类A和B属性，行为基本相同，则只需要在A的基础上增加些新内容即可，提高了代码的重用率，提高了编程的效率。

   3. 多态：同一个操作作用于不同的类的对象，将产生不同的执行结果。

   4. new是一个关键字，它为新创建的对象开辟内存空间，用于保存对象的成员变量和成员方法

类和继承

1. final修饰的类不能有派生类，String是典型的例子
2. Object类是所有java类的顶级基类。

3. 继承过程：

   1. 吸收基类成员：派生类把基类全部的成员接收过来

   2. 增加派生类成员：这部分内容是派生类对基类功能的扩展，要根据需要仔细考虑应当增加那些成员。在声明派生类时，一般还应当自己定义派生类的构造方法。因为构造风法时不能从基类继承的。

   3. 调整基类成员：隐藏同名基类成员。

   4. 方法重写的规则：

      1. 重写的方法返回值类型时基类方法返回值类型的子类或者相同

      2. 重写的方法具有相同的方法名

      3. 重写的方法参数列表必须相同

      4. 不能重写被标记为final的方法

      5. 重写的方法不能缩小访问权限。

      6. 不能重写基类私有的方法。

   5. 基类的引用可以指向派生类的对象：向上转型

      1. 好处：可以使用派生类强大的功能。可以抽取基类的共性。

      2. 指向派生类对象的基类的引用可以调用基类中定义的属性和方法

      3. 指向派生类的基类的引用不能调用派生类中定义而基类中没有定义的方法。

4. 包：命名空间，避免命名冲突。

   1. 包的名称就像是我们的姓，而class名称就像是我们的名字。

   2. 如果希望自己的类从属于一个包，可以使用package关键字

   
   package com.baidu.www;
   

抽象类和接口

1. abstract修饰的类称为抽象类，抽象类的特点：

   1. 不能实例化对象

   2. 类中可以定义抽象方法（abstract修饰的方法）

   3. 抽象类中可以没有抽象方法

2. 抽象类和接口

   1. 接口中的方法默认修饰符为public abstract

   2. 接口中所有的属性的修饰符默认为public static final;

   3. 接口和抽象类的区别：

      • 抽象类描述的是“是不是”的问题，而接口描述的是“有没有”的问题

      • 接口只有定义，不能有方法的实现，抽象类可以有定义和实现，方法可以在抽象类中实现。

      • 接口interface，抽象类abstract。

      • 实现接口的关键字implements，继承抽象类的关键字为extends，一个类可以实现多个接口，但是一个类只能继承一个抽象类。
3. abstract修饰的方法称为抽象方法，抽象方法只有方法的声明而没有方法的实现，即没有方法体。包含抽象方法的类本身必须是被声明为抽象的。
4. 抽象类的继承：派生类继承抽象类必须实现抽象类中所有的抽象方法，否则派生类也必须定义为抽象类。
5. Java中接口是一系列方法的声明，是一些方法特征的集合，接口可以看做事一种特殊的抽象类，其中包含常量和方法的声明，而没有变量和方法的实现。
6. 接口的定义：
   interface Test{ int compareTo(); }1. 每个类只能拥有一个超类，但是可以实现多个接口，接口中的方法默认是public类型，即不写权限修饰符。在其实现类中，不能降低权限。接口中的属性都是常量，即便不写关键字final
7. 接口的实现
   class Student implements 接口名{ ... }1. 一个类实现接口必须实现接口中所有的抽象方法，否则必须定义为抽象类。

8. 抽象类

   • 不能实例化，但是可以声明抽象类的引用。

   • 包含抽象方法的类必须定义为抽象类

   • 不包含抽象方法的类不一定不是抽象类

   • 抽象方法不含方法体，必须显式定义为abstract

   • 抽象类的派生类必须实现基类的所有抽象方法

9. 接口

   • 弥补Java单一继承机制的不足

   • 不能实例化，但是可以声明接口变量

   • 包含常量和方法的声明，不包含变量和方法的实现（常量可以没有final修饰，但是必须初始化，在接口实现类中不能修改值，方法可以没有abstract，在交界口裂实现类中必须实现）

   • 接口中的抽象方法不能有方法体

   • 接口不能继承类

10. Object类：所有Java类的祖先，每个类都可以使用Object作为基类。所有对象都是先这个类的方法。

    1. 在不明确给出超累的情况下，Java会自动把Object作为要定义类的超类。

    2. 可以使用类型为Object的变量指向任意类型的对象。

    3. Object类有一个默认构造方法public Object（），在构造派生类实例时，都会先调用这个默认构造方法。

    4. Object类的变量只能用作各种值的通用持有者。要对他们进行任何专门的操作，都要知道他们的原始类型并进行类型转换。

    ```

    Object obj = new MyObject();

    MyObject x = (MyObject)obj;

    ```1. Object方法

    1. Object（）：默认构造方法

    2. clone（）：创建并返回此对象的一个副本

    3. equals（Object obj）：指示某个其他对象是否与此对象相等。

    4. finalize（）：当垃圾回收期确定不存在对改对象更对的运用时，由杜希昂的垃圾回收器调用此方法。

    5. getClass（）：返回一个对象运行时类。

    6. hashCode（）：返回该对象的哈希码值

    7. notify（）：唤醒在此对象监视器上等待的单个线程。

    8. notifuAll（）：唤醒在此对象监视器上等待的所有线程。

    9. toString（）：返回该对象的字符串表示

    10. wait（）：导致当前的线程等待，直到其他线程调用此对象的notify或者notifyAll方法。

    11. equals方法：用于测试某个对象是否和另一个对象相等，它在Object类中的实现是判断两个对象是否指向同一块内存区域。

        • String中重写了equals方法，判断对象的值是否相同，==判断地址是否相同。

    12. toString方法：

        • Object类的toStirng方法返回一个字符串，该字符串由类名（对象是海内的一个实例），at标记符@和此对象哈希码的无符号十六进制表示组成。

        
        getClass().getName()+"@"+Integer.toHexString(hashCode())
        

多态

1. 一个对外接口，多个内在实现方法
2. 向上转型：就是基类引用指向派生类对象，既可以使用派生类强大的功能，也可以抽取基类的共性。
3. 在运行时期，将根据person这个对象引用实际的类型来获取对应的方法。所以才有多态性，对于基类中定义的方法，如果派生类中重写了该方法，那么基类类型的引用将会调用派生类中定义的这个方法。
4. 对于派生类中定义而基类中没有的方法无法调用。

包装器类

1. 概念：Java中的八种基本数据类型本身只能表示一种数据，为了能将基本类型是为对象来处理，并能链接相关的方法，Java为每个基本类型提供了包装类。
2. Java的八种基本数据类型对应的包装器类分别为Byte，Short，Character，Integer，Long，Float，Double，Boolean。

3. 创建包装器类型的对象：

   1. Java可以直接处理基本数据类型，但是在有些情况下需要将其作为对象来处理，这时就需要将其转化为包装器类型，在一定的场合，运用Java包装器类来解决问题，能大大提高编程效率。

   2. 创建的两种方法

   ```

   1.Integer i = new Integer(1);

   2.Double d = Double.valueOf(3.14);

   对象一旦赋值，其值将不能再改变。

   ```1. 有时也需要将包装器类型的对象转换为基本数据类型

   

内部类

1. 内部类是定义在另一个类中的类，也称内置类或者嵌套类

2. 特点：

   1. 内部类是一种编译时的语法，编译后生成的两个类是独立的两个类。（对于一个名为other的外部类和其内部定义的名为inner的内部类。编译完成后出现other.class和other$inner.class两个类）

   2. 内部类可以访问外部类的任何成员（包括私有成员），但是外部类不能直接访问内部类的成员。

   3. 内部类可为静态，可以用procected，private修饰，而外部类只能使用public和缺省的包访问权限。

   4. 用内部类定义再外部类中不可访问的属性。这样就可以再外部类中实现了比外部类的private还要小的访问权限。

3. 内部类的形式：

   1. 成员内部类

      • 作为外部类的一个成员存在，与外部类的属性，方法并列。内部类和外部类的实例变量可以共存。

      • 在外部类中使用内部类首先在外部类中new出内部类。

   2. 局部内部类

      • 局部内部类不能声明为接口

      • 想要使用局部内部类时，需要生成外部类对象，通过外部类对象调用外包方法，在方法中才能调用局部内部类。

   3. 匿名内部类

      • 匿名类没有类名，它必须继承一个类或者时实现一个接口。不能有显式的extends和implements子句。

   4. 静态内部类

      • 静态内部类定义在类中，在任何方法之外，使用static定义。

static修饰符

1. 静态属性特点：

   • 声明为static的属性也被称为类属性。

   • 当创建一个对象时，并不产生static属性的拷贝。

   • 该类所有的实例共享同一个static属性

   • 在类装载时，只分配一块存储空间，苏颇有此类的对象都可以操控此存储空间。

2. 访问形式：

   1. 通过类名.共有静态属性名

   2. 通过对象名.共有静态属性名

3. 使用规则：

   1. 在静态方法中，仅能直接调用其他的static类型的方法。

   2. 在静态方法中，只能直接访问static类型的属性。

   3. 在静态方法中，不能以任何方式使用this或者super。

   4. 静态代码块尽在该类贝介在时执行一次。

   5. 涉及到继承的时候，会优先初始化父类的static代码块，然后是子类的静态代码块。

4. 总结：

   1. static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。

   2. 被static修饰的成员变量和成员方法独立于该类的任何对象，他不依赖特定的实例，被类的所有实例共享。

   3. static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用，但是不饿能在其他类中通过类名来直接引用。

   4. 用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块。

枚举

1. 定义
   enum enum_name{num1,num2,num3} 定义星期的枚举： enum day{monday,tuesday,wensday,thursday,friday} 使用 day.monday1. 枚举的本质：Java中枚举的本质就是一个class

异常和断言

1. 异常分为两大类：

   • Error：描述了Java运行系统中的内部错误以及资源耗尽错误，唯一的解决方法：尽力使程序安全的终止。

   • Exception：程序中需要关注的。1.运行时异常，在Java虚拟机正常运行期间排除的异常，由程序错误导致，Java编译器允许程序中不对这类异常做出处理。2.其他异常：一般都是外部错误，Java编译器要求在程序中必须处理这类异常。

2. 小结：

   1. 系统自动排出的异常：所有系统定义的编译和运行异常都可以由系统自动抛出，称为标准异常，并且Java强烈要求程序进行完整的异常处理，给用户友好的提示，或者修正后使程序继续执行。

   2. 语句抛出的异常：用户程序自定义的异常和应用程序特ing的异常，必须借助于throws和throw语句来定义抛出的异常。

   3. throw和throws的区别：

      • throws语句用在方法声明后面，表示该方法会抛出哪些异常，使它的调用者知道要捕获这些异常

      • throw语句用在方法体内，表示抛出异常，是具体向外抛异常的动作，它抛出一个异常实例。

      • throws表示出现异常的一种可能性，滨海不是一定会发生这些异常；throw则是跑出来异常，执行throw则i顶跑出来某种异常。

3. 断言：assert

   1. 当需要在一个值为FALSE时中断当前操作的话，可以使用断言。

   2. assert后买你跟着冒号表达式，如果冒号之前为true，则冒号后面的被忽略，否则抛出AssertionError，错误内容为冒号后面的文字。

JDK8中的日期

1. Java中用于表示日期的类：Date类，Calendar类

2. 日期的格式化和解析：

   • DateFormate

   • SimpleDateFormate

3. java.time:

   • 瞬时时间：Instant

   • 年月日：LocalDate

   • 时间：LocalTime

   • 年月日时间：LocalDateTime

4. java.time.format

   • DateTimeFormatter

5. Instant类---时间戳

   • 获取当前时间，类似于java.util.Date:

     • Instant now = Instant.now();

     • Instant t = Instant.ofEpochSecond(100)

   • 和Date的转换

     • Date.from(now);

     • new Date().toInstant();

6. LocalDate类

   • LocalDate类只有年月日部分，没有小时分钟秒

   • 实例化

     • LocalDate today = LocalDate.now();

     • LocalDate christmas = LocalDate.of(2018,12,25);

7. LocalTime

   • LocalTime类只有小时分钟秒，没有年月日

   • 实例化：

     • LocalTime now = LocalTime.now();

     • LocalTime zero = LocalTime.of(0,0,0);//00:00:00

     • LocalTime mid

字符串，日期

1. 字符串常量类：String

   • String对象一经赋值，其值不可修改

   • 指的是所指向的内存值不可修改，但是指向可以修改

2. 字符串变量类：StringBuffer，StringBuilder

   1. 构造方法初始化

   ```

   String name = new String("Hello!");

   ```1. 字符串常量初始化

   ```

   String name = "Hello!";

   ```1. 区别

   • String str = "a"; 这个只是一个引用，内存中如果有“a"的话，str就指向它；如果没有，才创建它;

     如果你以后还用到"a"这个字符串的话并且是这样用：

     String str1 = "a"; String str2 = "a"; String str2 = "a"; 这4个变量都共享一个字符串"a"。

   • 而String str = new String("a");是根据"a"这个String对象再次构造一个String对象，将新构造出来的String对象的引用赋给str。

   1. String类是final的，无法被继承。
3. 字符串分割解析类：StringTokenizer

4. String类：

   1. 出于安全考虑，String类实现了值的不可变

   2. String中常用的字符串处理方法：

      • 字符串连接：concat（String str）/“+”运算符

      • 字符串查找：

        1. indexOf（String str）；

        2. lastIndexOf（String str）；

        3. charAt（int indexOf）；

        4. startsWith（String prefix）；

      • 字符串分割：

        1. split（String regex）字符串分割

        2. compareTo（String str）字符串比较

        3. equalslgnoreCase（String str）忽略大小写

      • 字符串替换：

        1. replace（char oldChar，char newChar）

      • 字符串求子串

        1. substring（int beginIndex，int endIndex）

      • 字符串大小写转换

        1. toUpperCase（）小写转大写

        2. toLowerCase（）大写转小写

5. StringBuffer类

   1. StringBuffer类是一个字符串变量类

      • StringBuffer对象的值可以修改

      • 主要用于对字符串做大量修改的操作时

   2. StringBuffer变量的初始化：

      • 构造方法初始化

      • StringBuffer stringBuffer = new StringBuffer（“Hello”）；

   3. StringBuffer类中常用的方法：

      • 字符串连接：append（Object obj）；

      • 字符串删除：delete（int start，int end）；

      • 字符串插入：insert（int offset，Object obj）；

      • 转换为String对象：toString（）；

6. StringBuilser类：

   1. StringBuilder类和StringBuffer类的调用是一致的。

   2. StringBuilder类和StringBuffer类的区别：

      • StringBuffer是线程安全的

      • StringBuilder是非线程安全的

7. StringTokenzier类

   1. StringTokenizer类主要用途是将字符串以界定符为界，分析为一个个独立的token（单词）

   2. StringTokenizer中的定界符可以自己指定。

   3. StringTokenizer常用的方法：

      • hasMoreTokens：是否有更多的分隔符

      • nextToken：返回下一个分隔符前的内容值

8. 日期的格式化：

   1. Java中用于表示日期的类

      • Date类

      • Calendar类

   2. 日期的格式化和解析

      • DateFormate

      • SimpleDateFormate

   3. Date类

      1. java.util.Date类实际上是一个包裹类，它包含的是一个长整型数据，表示的是从GMT1970年1月1日00：00：00这一刻之前或者之后经历的毫秒数

      2. Date类提供了两个重载的构造方法

         • Date()：以本地当前时间构造一个Date对象。

         • Date（long date）：以距离基准时间的毫秒数构造Date对象，

         
         Date date = new Date();
         
         System.out.println(date.getTime)
         

   4. Calendar类

   5. 日历类，Calendar类定义了足够的方法来表述日历的规则

   6. Calendar是一个抽象类，Java中提供了Calendar的一个具体的实现类GregorianCalendar

   7. Calender和Date的转换

      1. 从一个Calendar对象中获取Date对象

      ```

      Calendar calendar6

      ```1.

Java基础总结

原文：https://www.cnblogs.com/charlottepl/p/12538563.html