JAVA-基础语法

JAVA基础

1.何为编程

●为了使计算机理解人的意图，我们需要将需要解决的问题的思路方法和手段通过计算机能理解的方式告诉计算机，使计算机能够一步步去做，这个过程就是编程。

2.J2SE,J2EE,J2ME(Java的多个版本)

●J2SE：JAVA 2 Platform Standard Edition 标准版：用于桌面应用，也是J2EE的基础。

●J2EE：JAVA 2 Platform Enterprise Edition 企业版：用于企业应用，支持分布式部署。

●J2ME：JAVA 2 Platform Micro Edition 移动版：用于小型设备，J2EE的子集。

3.JDK和JRE和JVM的区别

●JVM：Java虚拟机，将字节码文件装载到内存并执行。

●JRE = JVM + 核心类库

●JVM = JRE + 开发工具

4.什么是跨平台性，原理是什么

●所谓跨平台性就是我们常说的一次编译到处运行，即在多种OS下都可以正常执行（那不也得有人家环境下的JVM嘛----）。原理为Java程序在编译后形成字节码文件，这个字节码文件是在JVM上进行执行的，不同的OS只要安装好对应的JVM，那么该系统就可以运行这个Java程序。

5.Java和C++的异同

●都是面向对象的语言，都具有封装、继承、多态的特性。

●Java中不提供指针，比较安全，而C++中提供指针直接访问内存，比较快捷。

●Java中的类只能单继承（但是一个类可以被多个类继承），C++中支持多继承

●Java中是有自动内存管理机制的，而C++需要手动释放无用内存

●Java是半解释型半编译型语言，而C++是编译型语言。

6.基础小知识

●Switch：在Java5之前，switch（exp）中exp只支持byte short int char 5开始引入了enum，而7开始引入了String。

●乘2的n次方：最快的方式，将这个数左移n位

●Math.round(11.5) = 12 ; Math.rount(-11.5 ) = -11;,round函数的原理是在参数的基础上+0.5然后四舍五入。

●float a = 3.4 (错误写法)，浮点型默认为double，这个语句相当于将一个double类型的赋值给一个float类型的，应该为float a = 3.4F

●short s1 = 1; s1 = s1 + 1; 这个是错误写法，因为1是整形，与short类型相加结果仍为int，所以需要用int类型接收。

●short s1 = 1; s1 += 1;这个正确，因为s1 += 1相当于s1 = （short（s1 + 1））；其中含有强制转换

●//单行注释 ； /*多行注释 */

●访问修饰符：public > protected > default > private

●&& 短路与， & ，||短路或 |

7.关键字

●final：修饰类->不可被继承；修饰方法->不可以被重些（overWrite）；修饰变量->不可以被修改（是引用地址不可以修改，但是内部的内容可以修改，但是如果指向了string，那就啥也改不了了，至于为啥，相信大家都懂的）

●finally：一般作用于try-catch代码块中，将一定要执行的代码放到finally代码块中。

●finalize：Object类的一个方法，由垃圾回收器调用，判断一个对象是否可回收（要回收之前的第一遍看能不能用这个复活）

●this：指对象本身；也可以做本类的构造函数->构造器只能存在一个

●super：值当前对象的父类引用；也可以做父类的构造函数，与this不能同时出现在一个构造函数里，因为this中必然会有super。

●static：用于创建独立于对象的域变量和域方法，在没有对象的时候也可以使用；还可以生成静态代码块（类被初次加载的时候，按顺序依次执行每个static块），只会在类加载的时候执行一次。静态只能访问静态。非静态既可以访问静态又可以访问非静态。

●break，continue，return：不用解释了吧。

8.面向对象和面向过程

●面向对象：有封装、继承、多态的特性，可以设计出低耦合的系统，性能比对面低，面向对象是模型化的，抽象出类，类中有数据有方法，需要的功能直接使用即可，不关心是如何实现的。

●面向过程：性能更好，类调用时需要实例化，资源开销大。Linux等看重性能的采用。面向过程是具体化的，解决一个问题，需要一步一步分析，实现。

9.面向对象三大特性

●封装性：把一个对象的属性私有化，同时提供一些可以被外界访问的属性的方法。体现为属性私有化；以及单例模式（构造器私有化）；访问修饰符；

继承性：在已存在的类的基础上创建新的类

​ ■子类拥有父类非Private的属性和方法（private的其实也获取到了，只是由于封装性不能使用）

​ ■子类可以拥有自己的属性和方法，即可以进行扩展

​ ■一个类只能继承一个类，但每个类可以被多个类继承

​ ■Object类是所有类的父类

​ ■关键字extends

​ ■子类可以重写（OverWrite）父类方法：子类对父类中同名同参数（这样就这名是一个方法）的方法进行覆盖

​ ▼重写方法的方法名和形参列表一定要相同（要不不能认为是同一个方法）

​ ▼重写方法的权限不小于重写方法的权限（覆盖人家，不得比人家大么(#^.#)）李式代换原则呀

​ ▼不能重写父类中声明为private的方法（相当于自己定义了，看不到上面的），如果嗲用父类中的方法，父类内部使用到这个private方法的话，则还是父类的private方法。（即正常重写后，父类中方法的调用也都是我们重写后的方法）

​ ▼重写方法的返回值类型应相同

​ ▼重写方法抛出的异常类型不大于父类被重写方法抛出的异常

​ ▼static不可重写

●多态性：程序中定义的引用变量所指的具体类型和通过该引用发出的方法在编译时并不确定，在运行时才确定。这样不用改源程序代码就可以让引用变量绑定到不同的类上，从而导致该引用调用的方法随之改变。

​ ■编译时多态（方法的重载（overload））：根据参数列表的不同来区分不同的函数。

​ ■运行时多态：动态绑定

​ ■向上转型：父类引用指向子类对象Person p = new Man();调用方法的时候，调用的是子类重写的方法，而且没有办法调用子类特有的方法（编译器只能编译父类有的方法，但在执行期，执行的是子类重写的方法）

​ ■想要调用子类特有的方法/属性，需要通过强制转换Man m = （Man）p，即向下转型，使用Instanceof关键字，判定是否为指定类（或其子类）的对象。if（p isinstanceof Man);

10.面向对象基本原则

●单一职责：类的功能单一

●开闭原则：对扩展开放，对修改封闭

●李式代换原则：子类可以替换父类出现在父类能出现的任何地方

●依赖倒置原则：要依赖于抽象，不要依赖于具体实现

●接口分离原则：采用多个专用接口比一个通用接口好

●迪米特法则：一个对象对其他对象知道的越少越好

11.抽象类和接口对比

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

●抽象类是对类的抽象，是一种设计模板，接口是行为的抽象，是一种行为规范。

●二者都不能实例化，都包含抽象方法，子类必须覆写

12.成员变量和局部变量的区别

●定义位置：成员变量定义在方法外部，类内部；局部变量在类的方法中定义。

●作用于：成员变量对整个类有效；局部变量指在方法语句体内有效

●存储位置：成员变量在堆内，局部变量在方法被调用，语句被执行时存在栈中。

●生命周期：成员变量随对象创建而存在，随对象消失而消失；局部变量当方法调用语句结束后自动释放。

●初始值：成员变量有默认初始值，局部变量没有。

13.为啥每个类都有个无参构造

●其子类执行构造方法时，会使用super（）来帮助子类进行初始化，如果没有这个无参构造，就会报错（那我final类是不是就不用了啊）

14.静态变量和实例变量

●静态变量不属于任何实例对象，属于类的，在内存中只有一份，在类的加载过程中，JVM只为静态变量分配一次内存空间。

●每次创建对象，都会为每个对象分配成员变量的内存空间。

15.内部类（LinkedList内部就有Node类）

●将一个类的定义放在另一个类的内部，作为类的一个属性

●静态内部类：定义在类内部的静态类，可以访问外部类所有的静态变量。new 外部类.静态内部类（）；

●成员内部类：定义在类内部的非静态类，可以访问外部类的所有变量和方法，无论静态非静态，私有或公有。外部实例类.new 内部类（）；

●局部内部类：定义在方法中的内部类，可以访问外部类的所有变量和方法（如果是在静态方法中，则只能访问外部类的静态变量和方法）。在对应方法中 new 内部类（）；

●匿名内部类：必须继承一个抽象类或实现一个接口。不能定义任何静态成员和静态方法。

●优点：内部类可以访问其外部类对象的内容，包括私有内容；不为同一包的其他类所见；不为同一包的其他类所见，具有良好的封装性；实现了多重继承。

16.对象相等判断

● ==：判断的是两个对象的地址是不是相同

●equals：是Object类的一个方法，如果没有覆写，则和== 一样。（String 的equals就覆写过了），重写的时候必须重写hashCode（）–因为hashCode的默认行为是对堆上的对象产生独享值，如果不重写，则两个对象无论如何也不会相等。（可我还是不理解为啥要重写这个···）

●hashCode：Object类的一个方法，用来获取哈希码，即用来确定该对象在哈希表中的索引位置。当我们把对象加入HashSet的时候，会先计算对象的hashCode值来判断对象加入的位置，同时与其他加入的对象的hashcode值比较，如果没有相同的hashcode则认为对象没有重复出现，如果有相同的hashcode值的对象，会调用equals方法来检查hashcode相等的对象是否真的相同。如果相同，hashset就不会让其添加成功，如果不同则重新散列到其他地方。

●如果两个对象相等，则其hashCode一定相同，并且equals返回也为ture，但是如果两个对象有相同的hashcode，他们也不一定相同。

17.值传递和引用传递

●在方法调用的时候，传递的参数是值的拷贝，不影响原来数据。

●方法调用的时候，传递的是引用的地址，即前后都指向一个内存空间。

18.常用的包

●java.lang：系统的基础类

●java.io：所有输入输出有关的类

●java.nio：完善io包中的功能，提高io包中性能的包

●java.net：与网络有关的类

●java.util：系统辅助类（集合类在里面）

●java.sql：数据库类

19.反射

●什么是反射：在运行状态中，我们知道任意一个类的所有属性和方法，并且对于任意一个对象，我们可调用其方法和属性（通过方法区那个模板吧）。是一种动态获取信息以及动态调用对象的方法。

●优点：运行期类型判断，动态加载类，提高代码灵活度。

●缺点：行难呢过比直接的Java代码慢很多

●应用场景：Spring的IOC底层就用到了反射。JDBC连接数据库时，使用Class.forName（）通过反射加载数据库驱动程序。

●获取反射的三种方法：

​ ■通过建立对象 Class classobj = wantaiying.getClass()；

​ ■通过路径 Class classobj2 = Class.forName(“相对路径”)

​ ■通过类名 Class classobj3 = Person.Class；

●获取私有属性：private int age = 19;

​ ■获取属性域： FIeld privateStringFiled = clazz.getDeclaredFiled（“age”）;

​ ■允许访问字段（私有才要）：privateStringFiled.setAccessiable(True);

​ ■获取私有字段值：int fieldValue = （int） privateStringFiled.get(obj);

●获取私有方法

​ ■使用Method字段接收

​ ■允许访问字段

​ ■使用invoke（对象，参数）获取返回值

20.常用API

●String

​ ■字符串常量池：位于堆内存中那个，专门用来存储字符串常量，可以提高内存的使用率，避免开辟多块存储空间相同的字符串；在创建字符串的时候JVM首先检查字符串常量池，如果该字符串已经在池中，则返回其引用，如果不存在，则实例化一个字符串放在池中，并返回其引用。

​ ■使用final定义其类，不能被继承，提高系统安全性。

​ ■底层是一个char数组（不可变，其实是可以通过反射改变的，但改变了也是新增了一个其他的String，又怎么算的上是改变呢）

​ ■String str = “i”;JVM会将其分配到产量池中；String str = new String（“i”）；则会分配到堆内存中；

​ ■String s = new String(“xyz”);实际上是创建了两个字符串对象，一个在堆上，一个在静态区。

​ ■常用方法：

​ ▼indexOf()：返回指定字符的索引

​ ▼charAt（）：返回指定索引的字符

​ ▼replace（）：字符串替换

​ ▼trim（）：去掉两端空格

​ ▼split（）：分割字符串返回一个分割后的字符串数组

​ ▼length（）：返回字符串长度

​ ▼getBytes（）：返回字符串的byte类型数组

​ ▼toLowerCase（）：将字符串转化为小写字母

​ ▼toUpperCase（）：将字符串转化成大写字母

​ ▼substring（）：截取字符串

​ ▼equals（）：字符串判等

●String、StringBuffer、StringBuilder

​ ■可变/不可变：String类底层使用字符数组来保存字符串：private final char value[]，所以不可变。StringBuilder与StringBuffer继承AbstractStringBuilder，也是使用字符数组来保存字符串，char value[]可变

​ ■线程安全性：String不可变，所以线程必然安全，StringBuffer是对方法加了同步锁，所以也是线程安全的，而StringBuilder是线程不安全的。

​ ■性能：每次String改变，都要生成一个新的string对象，并改变指针，剩余两个都是改变自身，但是StringBuilder不考虑线程安全，所以性能更高。

●包装类

​ ■自动装箱与拆箱：装箱即将基本类型用他们对应的引用类型包装起来，拆箱就是反过来

​ ■注：整形字面量的值在-128到127，那么自动装箱的时候不会new新的Integer对象，而是直接引用常量池的Integer对象，所以两个即使使用==判断也是相同的（享元模式，通过共享一些独享，降低内存中相同对象的数量）

​ ▼实现方式：Integer 内部私有类 IntegerCache，有一个叫Cache的Integer数组，长度为h - low + 1（h和low也都定义好了）。生成Integer对象先进行比较，在范围内就直接用。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Gfi8EMWL-1650275653986)(http://luxiaolumm.gitee.io/luxiao-lu-mm/pic/96.png)]

●Comparable接口（自然排序）：出自java.lang包，让类实现这个接口需要重写comparaTo方法。String就是实现了这个接口，可以直接使用Arrays.sort（）进行排序了

●Comparator接口（定制排序）：出自java.util包，创建个comparator对象，重写compare方法即可。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uxCSFGkg-1650275653987)(http://luxiaolumm.gitee.io/luxiao-lu-mm/pic/97.png)]

●Stack栈：常用方法size（）；pop（）；push（）；peek（）；

●Queue队列（接口->实现类LinkedList）：poll（）；size（）；add；peek（）；

●这里对也各个集合类不进行讲解，后续单出一节进行讲述。

21.深拷贝和浅拷贝（在设计模式的原型模式中有详细具体案例）

●浅拷贝：值类型会复制一份，引用类型仅仅拷贝引用地址

●深拷贝：引用类型会创建一个副本

22.序列化和反序列化

●Java对象 <->字节序列（byte 形式存储16进制），便于存储在文件中或在网络上传输

●序列化：实现了serializable接口，使用对象输出流的writeObject方法保存（实现了这个接口要生成一个静态常量serialVersionUID，可以直接定义为1L，作用是为了保证反序列化的时候找到正确的版本）

​ ■ObjectOutputStream（FileOutputStream）：用来保存基本数据类型或对象

​ ■void writeObejct（Object e）

●transient关键字：修饰属性，防止被序列化

●子类会继承父类序列化功能

●类的引用属性类型所在的类也要实现可序列化，否则不会序列化这个属性。

●温馨小提示：点开serializable接口看看就会发现，里面啥也没有，其实主要是在ObjectOutputStream的writeObject（）方法底层可以看到，如果一个对象既不是字符串又不是数组，枚举，而且也没有实现Serializable接口的话，就会抛出异常，所以仅仅就是一个标记作用，真正的序列化操作和这个接口没有关系。

●SerialVersionUID：序列化前后的唯一标识符，如果没有显式定义过，则编译器会自动为其生成一个

​ ■SerialVersionUID可以看做是序列化和反序列化过程的暗号，在反序列化时，JVM会把字节流中的序列化ID和被序列化类中的序列号ID对比，只有二者一致的时候才能反序列化。

​ ■在定义一个可序列化类的时候，没有显式的定义这个UID的话，则java运行环境会根据类的各方面信息为其自动生成一个默认值，当类的结构改动，值也会改动（之前序列化的，我把类改了，你就反序列化报错）

●两种特殊情况：

​ ■static修饰的字段不会被序列化：因为序列化保存的是对象的状态而非类的状态，所以会忽略

​ ■transient修饰的字段不会被序列化。（猜猜谁用到这个特性了，HashMap用到了哦）