Java基础部分知识总结

于 2020-02-24 20:29:12 发布
阅读量691 收藏 8
点赞数 1
CC 4.0 BY-SA版权
分类专栏： java 基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/tangxiaodou2015/article/details/104464984
本文详细对比了面向对象和面向过程的编程范式，分析了各自的优缺点，包括性能、可维护性、复用性和扩展性。深入探讨了面向对象的三大特性：封装、继承和多态，以及它们在软件设计中的应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

面向对象

面向对象和面向过程的区别
面向过程：

优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发，性能是最重要的因素。

缺点：没有面向对象易维护、易复用、易扩展

面向对象：

优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护

缺点：性能比面向过程低

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

封装：
封装把一个对象的属性私有化，同时提供一些可以被外界访问的属性的方法（get/set方法），如果属性不想被外界访问，我们大可不必提供方法给外界访问。

继承:
继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。通过使用继承我们能够非常方便地复用以前的代码。
关于继承如下 3 点：
1.子类拥有父类非 private 的属性和方法。
2.子类可以拥有自己的属性和方法，说白了就是子类可以对父类进行扩展
3.子类可以用自己的方式实现父类的方法。

多态：
谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量到底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。
在Java中有两种形式可以实现多态：继承（多个子类对同一方法的重写）和接口（实现接口并覆盖接口中同一方法）。
**

数据类型

**
Java有哪些数据类型：
定义：Java语言是强类型语言，对于每一种数据都定义了明确的具体的数据类型，在内存中分配了不同大小的内存空间。
分类：

整数类型byte,short,int,long
浮点类型float,double
字符型char
布尔型boolean
引用数据类型类(class)、接口(interface)、数组([])

Java基本数据类型图

在这里插入图片描述
Java语言采用何种编码方案？有何特点？
：Java语言采用Unicode编码标准，Unicode（标准码），它为每个字符制订了一个唯一的数值，因此在任何的语言，平台，程序都可以放心的使用。

什么Java注释
定义：用于解释说明程序的文字

分类：

  • 单行注释 格式： // 注释文字
  • 多行注释 格式： /* 注释文字 */
  • 文档注释 格式：/** 注释文字 */

作用：
在程序中，尤其是复杂的程序中，适当地加入注释可以增加程序的可读性，有利于程序的修改、调试和交流。注释的内容在程序编译的时候会被忽视，不会产生目标代码，注释的部分不会对程序的执行结果产生任何影响。

注意事项：多行和文档注释都不能嵌套使用。

访问修饰符

定义：Java中，可以使用访问修饰符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

  • private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
  • default (即缺省，什么也不写，不使用任何关键字）: 在同一包内可见，不使用任何修饰符，使用对象：类、接口、变量、方法。
  • protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
  • public : 对所有类可见。使用对象：类、接口、变量、方法

访问修饰符图

在这里插入图片描述
运算符
&运算符有两种用法：(1)按位与；(2)逻辑与。

&&运算符是短路与运算。逻辑与跟短路与的差别是非常巨大的，虽然二者都要求运算符左右两端的布尔值都是true 整个表达式的值才是 true。&&之所以称为短路运算，是因为如果&&左边的表达式的值是 false，右边的表达式会被直接短路掉，不会进行运算。

注意：逻辑或运算符（|）和短路或运算符（||）的差别也是如此。

关键字

final 有什么用？

  • 用于修饰类、属性和方法；
  • 被final修饰的类不可以被继承
  • 被final修饰的方法不可以被重写
  • 被final修饰的变量不可以被改变，被final修饰不可变的是变量的引用，而不是引用指向的内容，引用指向的内容是可以改变的

final finally finalize区别:

  • final可以修饰类、变量、方法，修饰类表示该类不能被继承、修饰方法表示该方法不能被重写、修饰变量表示该变量是一个常量不能被重新赋值。

  • finally一般作用在try-catch代码块中，在处理异常的时候，通常我们将一定要执行的代码方法finally代码块中，表示不管是否出现异常，该代码块都会执行，一般用来存放一些关闭资源的代码。

  • finalize是一个方法，属于Object类的一个方法，而Object类是所有类的父类，该方法一般由垃圾回收器来调用，当我们调用System.gc() 方法的时候，由垃圾回收器调用finalize()，回收垃圾，一个对象是否可回收的最后判断。

this关键字的用法
this是自身的一个对象，代表对象本身（可以理解为this代表就是当前类（本类））
this的用法在java中大体可以分为3种：

  • 普通直接引用，this指的是当前类对象
  • 形参和成员变量重名的时候用this.当前类的成员变量，他们之间通过this来区分
public Student(String name, int age) {
    this.name = name;
    this.age = age;
}
  • .引用本类的构造函数
class Student{
    private String name;
    private int age;
    
    public Student() {
    }
 
    public Student(String name) {
        this.name = name;
    }
    //本类的构造函数（有参数）
    public Student(String name, int age) {
        this(name);
        this.age = age;
    }
}

super关键字的用法

super可以理解为是指向自己父类对象，而这个父类指的是离自己最近的一个父类。
super也有三种用法：

  • 普通的直接引用，与this类似，super相当于是指向当前对象的父类的引用
  • 子类中的成员变量或方法与父类中的成员变量或方法同名时，用super进行区分
  • 引用父类构造函数

this与super的区别

  • super:　它引用当前对象的直接父类中的成员
  • this：它代表当前对象名
  • super()和this()类似,区别是，super()在子类中调用父类的构造方法，this()在本类内调用本类的其它构造方法
  • super()和this()均需放在构造方法内第一行。

static存在的主要意义

  • static的主要意义是在于创建独立于具体对象的域变量或者方法。以致于即使没有创建对象，也能使用属性和调用方法！

  • static关键字还有一个比较关键的作用（静态代码块）就是 用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。静态代码块会先于类加载之前执行

  • static优化程序的原因是：只会在类加载的时候执行一次（通常用来加载资源配置文件）
    static应用场景
    因为static是被类的实例对象所共享，因此如果某个成员变量是被所有对象所共享的，那么这个成员变量就应该定义为静态变量。
    因此比较常见的static应用场景有：

1.修饰成员变量
2.修饰成员方法
3.静态代码块
4修饰类（只能修饰内部类，也就是静态内部类

static注意事项

1.静态只能访问静态
2.非静态可以访问非静态的也可以访问静态的

流程控制语句：

break ,continue ,return 的区别及作用

1.break跳出当前循环，当前循环体直接结束
2.continue跳出本次循环，继续下一次循环
3.return程序返回，不再执行return下面的代码

类与接口

抽象类和接口的对比

  • 抽象类是用来捕捉子类的通用特性的。接口是抽象方法的集合。

  • 从设计层面来说，抽象类是一种模板设计，接口是行为的抽象，是一种行为的规范。

    相同点：

    • 接口和抽象类都不能被实例化
    • 都是被其他类继承，或者是实现
    • 都包含抽象方法，其子类（实现类）都必须重写这些抽象方法

    不同点：
    在这里插入图片描述

    普通类和抽象类的区别？

    • 普通类不能包含抽象方法，抽象类可以包含抽象方法。

    • 抽象类不能直接实例化，普通类可以直接实例化。

      抽象类能使用 final 修饰吗？
      1.不能，因为定义抽象类都是为了让其他类继承的，如果使用final的话那么就是不能被继承的类，所以final是不能修饰抽象类的。

变量与方法

成员变量与局部变量有什么区别？
定义：
1.成员变量：类中方法外的变量。
2.局部变量：类中方法中的变量。

成员变量和局部变量的区别
1.作用域

  • 成员变量：针对整个类有效。
  • 局部变量：只在某个范围内有效。(一般指的就是方法,语句体内)

2.存储位置

  • 成员变量：随着对象的创建而存在，随着对象的消失而消失，存储在堆内存中。
  • 局部变量：在方法被调用，或者语句被执行的时候存在，存储在栈内存中。当方法调用完，或者语句结束后，就自动释放。

3.生命周期

  • 成员变量：随着对象的创建而存在，随着对象的消失而消失
  • 局部变量：当方法调用完，或者语句结束后，就自动释放。

4.初始值

  • 成员变量：有默认初始值
  • 局部变量：没有默认初始值，使用前必须赋值。

5.使用规则

  • 在使用变量时需要遵循的原则为：就近原则首先在局部范围找，有就使用；接着在成员位置找。

构造方法有哪些特性？

  • 名字与类名相同；
  • 没有返回值，但不能用void声明构造函数；
  • 生成类的对象时自动执行，无需调用。（创建对象的时候直接调用）

静态变量和实例变量区别？

  • 静态变量： 静态变量由于不属于任何实例对象，属于类的，所以在内存中只会有一份，在类的加载过程中，JVM只为静态变量分配一次内存空间。
  • 实例变量： 每次创建对象，都会为每个对象分配成员变量内存空间，实例变量是属于实例对象的，在内存中，创建几次对象，就有几份成员变量。

静态变量与普通变量区别？

  • tatic变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。还有一点就是static成员变量的初始化顺序按照定义的顺序进行初始化。

静态方法和实例方法有何不同？

  • 在外部调用静态方法时，可以使用==“类名.方法名”==的方式，也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。
  • 静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制

重写与重载

构造器（constructor）是否可被重写（override）？
构造器不能被继承，因此不能被重写，但可以被重载。

重载（Overload）和重写（Override）的区别。重载的方法能否根据返回类型进行区分？
定义：方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。

  • 重载：发生在同一个类中，方法名相同参数列表不同（参数类型不同、个数不同、顺序不同），与方法返回值和访问修饰符无关，即重载的方法不能根据返回类型进行区分
  • 重写：发生在父子类中，方法名、参数列表必须相同，返回值小于等于父类，抛出的异常小于等于父类，访问修饰符大于等于父类（里氏代换原则）；如果父类方法访问修饰符为private则子类中就不是重写。

对象相等判断

== 和 equals 的区别是什么？

  • = = : 它的作用是判断两个对象的地址是不是相等。即，判断两个对象是不是同一个对象。(基本数据类型 = = 比较的是值，引用数据类型 == 比较的是内存地址)

  • equals() : 它的作用也是判断两个对象是否相等。但它一般有两种使用情况：
    1.类没有重写 equals() 方法。则通过 equals() 比较该类的两个对象时，等价于通过“==”比较这两个对象。
    2.类重写了 equals() 方法。一般，我们都重写 equals() 方法来两个对象的内容相等；若它们的内容相等，则返回 true (即，认为这两个对象相等)。

hashCode 与 equals
hashCode()与equals()的相关规定

  • 如果两个对象相等，则hashcode一定也是相同的
  • 两个对象相等，对两个对象分别调用equals方法都返回true
  • 两个对象有相同的hashcode值，它们也不一定是相等的

IO流

java 中 IO 流分为几种?

  • 按照流的流向分，可以分为输入流和输出流；
  • 按照操作单元划分，可以划分为字节流和字符流；
  • 按照流的角色划分为节点流和处理流。

InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。
OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输出流。

反射

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
反射机制优缺点

  • 优点： 运行期类型的判断，动态加载类，提高代码灵活度。
  • 缺点：性能瓶颈：反射相当于一系列解释操作，通知 JVM 要做的事情，性能比直接的java代码要慢很多。

反射机制的应用场景有哪些？
举例：①我们在使用JDBC连接数据库时使用Class.forName()通过反射加载数据库的驱动程序；②Spring框架也用到很多反射机制，最经典的就是xml的配置模式。Spring 通过 XML 配置模式装载 Bean 的过程：1) 将程序内所有 XML 或 Properties 配置文件加载入内存中; 2)Java类里面解析xml或properties里面的内容，得到对应实体类的字节码字符串以及相关的属性信息; 3)使用反射机制，根据这个字符串获得某个类的Class实例; 4)动态配置实例的属性

Java获取反射的三种方法
1.通过new对象实现反射机制 2.通过路径实现反射机制 3.通过类名实现反射机制

public class Student {
    private int id;
    String name;
    protected boolean sex;
    public float score;
}

public class Get {
    //获取反射机制三种方式
    public static void main(String[] args) throws Exception {
        //方式一(通过建立对象)
        Student stu = new Student();
        Class classobj1 = stu.getClass();
        System.out.println(classobj1.getName());
        //方式二（所在通过路径-相对路径）
        Class classobj2 = Class.forName("com.itranhui.Student");
        System.out.println(classobj2.getName());
        //方式三（通过类名）
        Class classobj3 = Student.class;
        System.out.println(classobj3.getName());
    }
}

String类

String 类的常用方法。

  • indexOf()：返回指定字符的索引。
  • charAt()：返回指定索引处的字符。
  • replace()：字符串替换。
  • trim()：去除字符串两端空白。
  • split()：分割字符串，返回一个分割后的字符串数组。
  • getBytes()：返回字符串的 byte 类型数组。
  • length()：返回字符串长度。
  • toLowerCase()：将字符串转成小写字母。
  • toUpperCase()：将字符串转成大写字符。
  • substring()：截取字符串。
  • equals()：字符串比较。

在使用 HashMap 的时候，用 String 做 key 的好处

HashMap 内部实现是通过 key 的 hashcode 来确定 value 的存储位置，因为字符串是不可变的，所以当创建字符串时，它的 hashcode 被缓存下来，不需要再次计算，所以相比于其他对象更快。

String和StringBuffer、StringBuilder的区别是什么？String为什么是不可变的

可变性：
String类中使用字符数组保存字符串，private　final　char　value[]，所以string对象是不可变的。StringBuilder与StringBuffer都继承自AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存字符串，char[] value，这两种对象都是可变的。

线程安全性:
String中的对象是不可变的，也就可以理解为常量，线程安全。AbstractStringBuilder是StringBuilder与StringBuffer的公共父类，定义了一些字符串的基本操作，如expandCapacity、append、insert、indexOf等公共方法。StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。

性能:
每次对String 类型进行改变的时候，都会生成一个新的String对象，然后将指针指向新的String 对象。StringBuffer每次都会对StringBuffer对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用StirngBuilder 相比使用StringBuffer 仅能获得10%~15% 左右的性能提升，但却要冒多线程不安全的风险。

对于三者使用的总结

如果要操作少量的数据用 = String
单线程操作字符串缓冲区 下操作大量数据 = StringBuilder
多线程操作字符串缓冲区 下操作大量数据 = StringBuffer

集合总结

Collection（单列集合）

1.Set:

  • TreeSet：基于红黑树实现，支持有序性操作，例如：根据一个范围查找元素的操作。但是查找效率不如 HashSet，HashSet 查找的时间复杂度为 O(1)，TreeSet 则为 O(logN)。

  • HashSet：基于哈希表实现，支持快速查找，但不支持有序性操作。并且失去了元素的插入顺序信息，也就是说使用 Iterator 遍历 HashSet 得到的结果是不确定的。

  • LinkedHashSet：具有 HashSet 的查找效率，且内部使用双向链表维护元素的插入顺序。

2.List

  • ArrayList：基于动态数组实现，支持随机访问。
  • Vector：和 ArrayList 类似，但它是线程安全的。
  • LinkedList：基于双向链表实现，只能顺序访问，但是可以快速地在链表中间插入和删除元素。不仅如此，LinkedList 还可以用作栈、队列和双向队列。

Map（双列集合）

  • TreeMap：基于红黑树实现。
  • HashMap：基于哈希表实现。
  • HashTable：和 HashMap 类似，但它是线程安全的，这意味着同一时刻多个线程可以同时写入 HashTable 并且不会导致数据不一致。它是遗留类，不应该去使用它。现在可以使用 ConcurrentHashMap 来支持线程安全，并且 ConcurrentHashMap 的效率会更高，因为 ConcurrentHashMap 引入了分段锁。
  • LinkedHashMap：使用双向链表来维护元素的顺序，顺序为插入顺序或者最近最少使用（LRU）顺序。

ArrayList 和 LinkedList 的区别

  • 是否保证线程安全： ArrayList 和 LinkedList 都是不同步的，也就是不保证线程安全；

  • 底层数据结构： Arraylist 底层使用的是Object数组；LinkedList 底层使用的是双向循环链表数据结构；

  • 是否支持快速随机访问： LinkedList 不支持高效的随机元素访问，而ArrayList 实现了RandmoAccess 接口，所以有随机访问功能。快速随机访问就是通过元素的序号快速获取元素对象(对应于get(int index)方法)。

  • 内存空间占用： ArrayList的空 间浪费主要体现在在list列表的结尾会预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗比ArrayList更多的空间（因为要存放直接后继和直接前驱以及数据）。

ArrayList 的扩容机制

  • 使用 add 方法的时候首先调用 ensureCapacityInternal 方法，传入 size+1 进去，检查是否需要扩充 elementData 数组的大小；
  • newCapacity = 扩充数组为原来的 1.5 倍(不能自定义)，如果还不够，就使用它指定要扩充的大小 minCapacity ，然后判断 minCapacity 是否大于 MAX_ARRAY_SIZE(Integer.MAX_VALUE - 8) ，如果大于，就取 Integer.MAX_VALUE；
  • 扩容的主要方法：grow；
  • ArrayList 中 copy 数组的核心就是 System.arrayCopy 方法，将 original 数组的所有数据复制到 copy 数组中，这是一个本地方法。

HashMap 的实现原理/底层数据结构？JDK1.7 和 JDK1.8

  • JDK1.7：Entry数组 + 链表
  • JDK1.8：Node 数组 + 链表/红黑树，当链表上的元素个数超过 8 个并且数组长度 >= 64 时自动转化成红黑树，节点变成树节点，以提高搜索效率和插入效率到 O(logN)。Entry 和 Node 都包含 key、value、hash、next 属性。

HashMap 的 put 方法的执行过程

  • 当我们想往一个 HashMap 中添加一对 key-value 时，系统首先会计算 key 的 hash 值，然后根据 hash 值确认在 table 中存储的位置。若该位置没有元素，则直接插入。否则迭代该处元素链表并依次比较其 key 的 hash 值。如果两个 hash 值相等且 key 值相等(e.hash == hash && ((k = e.key) == key || key.equals(k)))，则用新的 Entry 的 value 覆盖原来节点的 value。如果两个 hash 值相等但 key 值不等 ，则将该节点插入该链表的链头。

HashMap 的 resize 方法的执行过程
有两种情况会调用 resize 方法：

  • 第一次调用 HashMap 的 put 方法时，会调用 resize 方法对 table 数组进行初始化，如果不传入指定值，默认大小为 16。

  • 扩容时会调用 resize，即 size > threshold 时，table 数组大小翻倍。

每次扩容之后容量都是翻倍。扩容后要将原数组中的所有元素找到在新数组中合适的位置。
HashMap 与 HashTable 的区别是什么？

  • 线程是否安全： HashMap 是非线程安全的，HashTable 是线程安全的；HashTable 内部的方法基本都经过 synchronized 修饰。（如果你要保证线程安全的话就使用 ConcurrentHashMap 吧！）；
  • 效率： 因为线程安全的问题，HashMap 要比 HashTable 效率高一点。另外，HashTable 基本被淘汰，不要在代码中使用它；
  • 对Null key 和Null value的支持： HashMap 中，null 可以作为键，这样的键只有一个，可以有一个或多个键所对应的值为 null。。但是在 HashTable 中 put 进的键值只要有一个 null，直接抛出 NullPointerException。
  • 初始容量大小和每次扩充容量大小的不同 ： ①创建时如果不指定容量初始值，Hashtable 默认的初始大小为11，之后每次扩充，容量变为原来的2n+1。HashMap 默认的初始化大小为16。之后每次扩充，容量变为原来的2倍。②创建时如果给定了容量初始值，那么 Hashtable 会直接使用你给定的大小，而 HashMap 会将其扩充为2的幂次方大小。也就是说 HashMap 总是使用2的幂作为哈希表的大小,后面会介绍到为什么是2的幂次方。
  • 层数据结构： JDK1.8 以后的 HashMap 在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间。Hashtable 没有这样的机制。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值