【Java基础】Java面试题一 面向对象与面向过程的区别 基本类型与包装类的区别 隐式转换和强制转换 String StringBuffer

javaOOP(面向对象)

面向对象与面向过程的区别

面向过程

面向过程：
面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了，强调的就是功能行为，功能的执行过程，即先后顺序，

例如五子棋小游戏，面向过程的设计思路就是首先分析问题的步骤：1、开始游戏，2、黑子先走，3、绘制画面，4、判断输赢，5、轮到白子，6、绘制画面，7、判断输赢，8、返回步骤2，9、输出最后结果。把上面每个步骤用不同的方法来实现。
网上看到的小例子

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

面向对象

1)面向对象： 一种基于面向过程的新编程思想，面向对象是把构成问题事务分解成各个对象,把一切都看成对象，而对象一般都由属性+方法组成！
2)具备某种功能的实体，称为对象。面向对象最小的程序单元是：类。具有同种属性的对象称为类，是个抽象的概念.他定义了它所包含的全体对象的公共特征和功能，对象就是类的一个实例化.
3)比如定义一个动物类,里面的狗就是一个具体的对象,就是对动物类的实例化.
4)面向对象更加符合常规的思维方式，稳定性好，可重用性强，易于开发大型软件产品，有良好的可维护性。
5)面向对象有三大特性，分别是封装性、继承性和多态性
6)在软件工程上，面向对象可以使工程更加模块化，实现更低的耦合和更高的内聚。

整个五子棋可以分为1、黑白双方，这两方的行为是一模一样的，2、棋盘系统，负责绘制画面，3、规则系统，负责判定诸如犯规、输赢等。第一类对象（玩家对象）负责接受用户输入，并告知第二类对象（棋盘对象）棋子布局的变化，棋盘对象接收到了棋子的变化就要负责在屏幕上面显示出这种变化，同时利用第三类对象（规则系统）来对棋局进行判定。

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

面向对象有三大特性，分别是封装性、继承性和多态性

多态(一个对象拥有多种状态,可以减低耦合)

代码当中体现多态性，其实就是一句话： 父类引用指向子类对象
格式： 父类名称 对象名 = new 子类名称（）；
或者： 接口名称 对象名 = new 实现类名称（）；

继承父类与实现接口是多态的前提,父类人引用指向子类对象小明,让小明有了学生状态,又有了人类状态

B/S架构与C/S架构

B/S(Browser/Server)，浏览器/服务器程序
C/S(Client/Server)，客户端/服务端，桌面应用程序

Java都有那些开发平台？

JAVA SE：主要用在客户端开发
JAVA EE：主要用在web应用程序开发
JAVA ME：主要用在嵌入式应用程序开发

什么是JDK？什么是JRE?

JDK：java development kit：java开发工具包，是开发人员所需要安装的环境
JRE：java runtime environment：java运行环境，java程序运行所需要安装的环境

关键字 final static

static

只要类被加载了,方便在没有创建对象的情况下，仅仅通过类本身来进行调用（方法/变量/代码块）。
1.变量,被static修饰的变量是唯一的

静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。
而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。

static成员变量的初始化顺序按照定义的顺序进行初始化。
　静态成员变量虽然独立于对象，但是不代表不可以通过对象去访问，所有的静态方法和静态变量都可以通过对象访问（只要访问权限足够）。
static是不允许用来修饰局部变量

2.方法
静态方法不依附于任何对象,所以在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用

非静态成员方法中是可以访问静态成员方法/变量
我们最常见的static方法就是main方法，至于为什么main方法必须是static的，现在就很清楚了。因为程序在执行main方法的时候没有创建任何对象，因此只有通过类名来访问。
3.代码块
静态代码块可以优化程序性能。static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。
只需要进行一次的初始化操作都放在static代码块中进行

final

final 可以修饰类,方法,变量
1.修饰类,该类不能被继承,final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。
2.修饰方法 方法不能被子类重写,类的private方法会隐式地被指定为final方法。
3,修饰变量 :　对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象

只有在编译期间能确切知道final变量值的情况下，编译器才会进行这样的优化
当final变量是基本数据类型以及String类型时，如果在编译期间能知道它的确切值，则编译器会把它当做编译期常量使用。也就是说在用到该final变量的地方，相当于直接访问的这个常量，不需要在运行时确定

public class Test {
    public static void main(String[] args)  {
        String a = "hello2"; 
        final String b = "hello";
        String d = "hello";
        String c = b + 2; 
        String e = d + 2;
        System.out.println((a == c));
        System.out.println((a == e));
    }
}

protected

父类的protected成员是包内可见的，并且对子类可见；
若子类与父类不在同一包中，那么在子类中，子类实例可以访问其从父类继承而来的protected方法，而不能访问父类实例的protected方法。

总结总结，其实就是爹的东西在家庭里的儿子能用，在家庭之外的儿子不能用，要用只能用爹买给你的

String StringBuffer StringBuilder三个对象引用的区别

1.他们三者都是对象,但是String是不可变对象,被final修饰的.“对String对象的任何改变都不影响到原对象，相关的任何change操作都会生成新的对象”,当在编译期间,String s=“hello” ,这种 字符串常量 被放在,编译期间的字符串常量池中
2.而StringBuffer和StringBuilder是可变对象
3.String 为字符串常量,每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象
4.StringBuffer 字符串变量（线程安全,StringBuffer类的成员方法前面多了一个关键字：synchronized）则不是生成新的对象,而是调用append()方法和 insert()方法, insert (4,"")方法则在指定的点添加字符
5.StringBuilder 字符串变量（非线程安全）

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

例子1: 方法一String s1=“hello”; String s2=“world”; String s1+=s2;
方法二 StringBuffer s1=“hello” StringBuffer s2 s1=s1.append(s2);
方法一因为要生成三个对象,会被方法二生成两个对象要慢

一般来说:String、StringBuilder、StringBuffer三者的执行效率：
　　StringBuilder > StringBuffer > String
而在某些特别情况下， String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffer 对象的拼接，所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢，而特别是以下的字符串对象生成中， String 效率是远要比 StringBuffer和StringBuilder 快的：
String S1 = “This is only a” + “ simple” + “ test”;
在编译期间的优化成 String S1="This is onlu a simple test "
StringBuffer S2 = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);

Java中有几种数据类型(8种)

整形：byte,short,int,long
浮点型：float,double
字符型：char
布尔型：boolean

Java中的包装类都是那些？

byte：Byte
short：Short，
int：Integer
long：Long
float：Float
double：Double
char：Character
boolean：Boolean

基本类型与包装类的区别

1.包装类型可以为 null，而基本类型不可以

《阿里巴巴 Java 开发手册》上有详细的说明 数据库的查询结果可能是
null，如果使用基本类型的话，因为要自动拆箱（将包装类型转为基本类型，比如说把 Integer 对象转换成 int 值），就会抛出
NullPointerException 的异常。

2.包装类型可用于泛型，而基本类型不可以
3.基本类型比包装类型更高效
基本类型在栈中直接存储的具体数值，而包装类型则存储的是堆中的引用
包装类要new一个,而基本类型不用,而且两个包装类型在使用“==”进行判断的时候，判断的是其指向的地址是否相等,而基本类型不用

自动装箱和自动拆箱

把基本类型转换成包装类型的过程叫做装箱。
反之，把包装类型转换成基本类型的过程叫做拆箱

装箱就是自动将基本数据类型转换为包装器类型（int–>Integer）；调用方法：Integer的valueOf(int) 方法
拆箱就是自动将包装器类型转换为基本数据类型（Integer–>int）。调用方法：Integer的intValue方法 在Java
SE5之前，如果要生成一个数值为10的Integer对象，必须这样进行： Integer i = new Integer(10);
而在从Java SE5开始就提供了自动装箱的特性，如果要生成一个数值为10的Integer对象，只需要这样就可以了： Integer i =
10;

当需要进行自动装箱时，如果数字在 -128 至 127 之间时，会直接使用缓存中的对象，而不是重新创建一个对象

隐式转换和强制转换((包含关系,小的可以转为大的,但是大的不能自动转为小的))

隐式转换

隐身转换:又叫自动类型转换,就是小范围的变量转换为大范围的数据

从小到大，可以隐式转换，数据类型将自动提升。
byte，short，char -->int -->long -->float -->double
注意：long是8个字节，float是4个字节。
long是整数，float是浮点型，整数和浮点数的存储规则不一样，记住一点long的范围是小于float的。
例 :
byte a=10;
int b=a;
当编译int b=a 时， a隐式转换为int类型。

强制转换

强制转换:又叫显示转换，就是把一个大类型的数据强制赋值给小类型的数据

例 :
int a=10;
byte b=(byte)a;

程序的结构有那些？

顺序结构 选择结构 循环结构

Java中各种数据默认值

Byte,short,int,long默认是都是0 Boolean默认值是false Char类型的默认值是\u0000
Float与double类型的默认是0.0 对象类型的默认值是null

抽象类与接口的区别

1.abstract修饰符的class即为抽象类，abstract 类不能创建实例对象,因为其中有抽象方法,如果实例化,无法调用抽象方法,抽象类与普通类没有太大的区别,就是多了抽象方法,所以抽象类无法实例化。

abstract
class类中定义抽象方法必须在具体(Concrete)子类中实现，所以，不能有抽象构造方法或抽象静态方法。如果子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型。

2.接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。

集合

1.集合框架结构图

2.集合与数据的区别

3.collection集合方法

4.常用集合的分类：

Collection 接口的接口 对象的集合（单列集合）
├——-List 接口：元素按进入先后有序保存，可重复
│—————-├ LinkedList 接口实现类， 链表，查询慢，增删快 插入删除， 没有同步， 线程不安全
│—————-├ ArrayList 接口实现类， 数组，查询快，增删慢 随机访问， 没有同步， 线程不安全
│—————-└ Vector 接口实现类 数组，查询快，增删慢 同步， 线程安全
│ ———————-└ Stack 是Vector类的实现类
└——-Set 接口： 仅接收一次，不可重复，并做内部排序
├—————-└HashSet 使用hash表（数组）存储元素,元素的唯一性是靠所存储元素类型是否重写hashCode()和equals()方法来保证的，如果没有重写这两个方法，则无法保证元素的唯一性
│————————└ LinkedHashSet 链表维护元素的插入次序
└ —————-TreeSet 底层实现为二叉树，元素排好序
Map 接口 键值对的集合 （双列集合）
├———Hashtable 接口实现类， 同步， 线程安全
├———HashMap 接口实现类 ，没有同步， 线程不安全-
│—————–├ LinkedHashMap 双向链表和哈希表实现
│—————–└ WeakHashMap
├ ——–TreeMap 红黑树对所有的key进行排序
└———IdentifyHashMap

i++ ++i

没有参与表达式运算时,没有区别,比如for循环
如果参与表达式运算,谁在前面先执行谁

JVM java虚拟机

内存结构:

java虚拟机管理的内存将分为下面五大区域

程序计数器

程序计数器是一块很小的内存空间，它是线程私有的，可以认作为当前线程的行号指示器,每一个线程都有一个。

Java栈（虚拟机栈）

每个方法被执行的时候都会创建一个栈帧用于存储局部变量表，操作栈，动态链接，方法出口等信息。每一个方法被调用的过程就对应一个栈帧在虚拟机栈中从入栈到出栈的过程
平时说的栈一般指局部变量表部分。
局部变量表:一片连续的内存空间，用来存放方法参数，以及方法内定义的局部变量，存放着编译期间已知的数据类型(八大基本类型和对象引用(reference类型),returnAddress类型。它的最小的局部变量表空间单位为Slot，虚拟机没有指明Slot的大小，但在jvm中，long和double类型数据明确规定为64位，这两个类型占2个Slot，其它基本类型固定占用1个Slot。

局部变量表所需要的内存空间在编译期完成分配，当进入一个方法时，这个方法在栈中需要分配多大的局部变量空间是完全确定的，在方法运行期间不会改变局部变量表大

Java虚拟机栈可能出现两种类型的异常：
1.线程请求的栈深度大于虚拟机允许的栈深度，将抛出StackOverflowError。
2. 虚拟机栈空间可以动态扩展，当动态扩展是无法申请到足够的空间时，抛出OutOfMemory异常。

堆

堆是java虚拟机管理内存最大的一块内存区域，因为堆存放的对象是线程共享的，所以多线程的时候也需要同步机制,用于存放对象实例及数组都要在堆上分配内存
Java堆可以存在物理上不连续的内存空间，就像磁盘空间只要逻辑是连续的即可。它的内存大小可以设为固定大小，也可以扩展。

方法区

是所有线程共享的内存区域，为了区分堆，又被称为非堆。
用于存储已被虚拟机加载的类信息、常量、静态变量，如static修饰的变量加载类的时候就被加载到方法区中。
java虚拟机对方法区比较宽松，除了跟堆一样可以不存在连续的内存空间，定义空间和可扩展空间，还可以选择不实现垃圾收集。