Java面向对象基础知识复习复习进程

复习
1保留字
goto
2.标识符
数字、字母、下划线、$组成，不能以数字开头，不能使用关键字或保留字，不能包含空格，不能包含除$以外的符号，不能包含中文
起名规范：包名：所有字母小写：aaabbbccc
类名/接口名：所有单词首字母大写：AaaBbbCcc
变量名/函数名：第一个字母全小写，后面单词首字母大写：aaaBbbCcc
常量名：所有字母大写，单词之间用下划线连接：AAA_BBB_CCC
3.基本数据类型、字节数、大小、包装类
byte 1字节2^7-1 Byte
short 2字节2^15-1 Short
int 4字节2^31-1 Integer
long 8字节2^63-1 Long
float 4字节2^31-1 Float
double 8字节2^63-1 Double
char 2字节2^15-1 Character
boolean 1位Boolean
4.a++、++a
b=a++：temp=a，a=a+1，b=temp
b=++a：a=a+1，b=a
5.&和&&的区别
&：无论左侧结果是什么，两侧都需要进行运算
&&：当左侧为false时，右侧不参与运算
6.最有效的方式计算2乘以8
2<<3
7.if和switch的区别
if后面是条件表达式，返回的是boolean类型，switch后面是byte/short/int/char类型的表达式
8.能被switch的数据类型有哪些
boolean、short、int、char（jdk1.7之后增加了String）
9.for循环执行顺序
for(初始化表达式1；循环条件表达式2；循环后操作表达式3){
执行语句（循环体）；
}
执行顺序：先执行表达式1进行初始化；根据表达式2判断是否执行循环体，如果返回true 执行循环体，如果false退出循环；执行完循环体一次后，执行表达式3，这个过程修改变量；
再执行表达式2以此循环
10.数组和链表的区别
数组链表
查快慢
改慢快
增删慢快
11.面向对象三大特点
封装：将数据等集合在一个单元内，称之为类，被封装的对象被称之为抽象数据类型
继承：可传递性，如果C从B类中派生，B又从A类中派生，那么C既继承了B类中声明的成员，也继承了A类中的成员
多态：指同一操作作用于不同的对象可以有不同的解释，也会产生不同的结果
12.类中主要包含哪几个元素，分别有什么作用
属性：用来定义对象的数据
方法：用来定义对象的行为
构造方法：用来创建对象
内部类：作为类的一个成员存在，能够访问外部类的属性和方法
代码块：用来在类加载时执行操作或者在每次实例化前执行通用操作
13.成员变量（全局变量）和局部变量的区别
1.定义的位置：
成员变量：定义在类中
局部变量：定义在方法体内，语句中
2.生命周期：
成员变量：也称为实例变量，随着对象的出现而出现，随着对象的消失而消失
局部变量：一旦作用域结束立即释放
3.内存的位置：
成员变量：存储在堆内存中
局部变量：存储在栈内存中
4.初始值：
成员变量：可以不赋初值，有默认的初始值，数据类型的默认值
局部变量：可以不赋初值。

但是不能使用，一旦使用就会报错，所以必须赋初值
5.局部变量会覆盖掉全局变量
14.访问控制修饰符的作用域
public：不同包中都可以
protected：包中的类和包外的子类
default：包中的类
private：只能本类中使用
15.静态变量和实例变量的区别
1.生命周期：
成员变量：又叫实例变量，是随着对象的出现而出现，随着对象的消失而消失
静态变量：又叫类变量，是随着类的加载而出现，随着类的消失而消失
2.内存中的存储位置：
成员变量：存储在堆内存的对象中
静态变量：存储在方法区的静态区中
3.存储的数据特点：
成员变量：存储的数据是对象的特有数据
静态变量：存储的数据是对象的共享数据
4.调用方式：
成员变量：只能被对象所调用
静态变量：能被对象调用，也可以被类名调用
16.final abstract
String不能被继承，因为被final修饰，被final修饰的类不能被继承
final和abstract不能共存：abstract修饰的方法需要依赖子类实现，而final修饰的方法不能被继承
17.GC垃圾回收
垃圾回收机制负责的是回收内存中的对象，不回收任何资源
程序员负责释放内存，System.gc进行垃圾回收
程序无法精准的控制垃圾回收的运行，垃圾回收会在任何时间自动执行，程序不能指定在
什么时间回收，只能系统自己决定回收时间
垃圾回收之前会执行finalize再次激活，一旦回收永久失去引用
垃圾回收的回收机制：分代复制垃圾回收、标记垃圾回收、增量垃圾回收
18.单例模式：
1.构造函数私有化
2.提供一个静态的自己的全局变量
3.提供一个get()方法，用来获取这个全局变量
饿汉式：
public class TestSingle {
//构造函数私有化
private TestSingle(){
}
//提供一个静态的全局变量
private static TestSingle instance = new TestSingle();
//提供一个get方法获取全局变量
public static TestSingle getInstance(){
return instance;
}
}
懒汉式：
public class TestSingleton {
//构造函数私有化
private TestSingleton(){
}
//提供一个静态的全局变量
private static TestSingleton instance=null;
//提供一个get方法获取全局变量
public static TestSingleton getInstance(){
if(instance==null){
instance =new TestSingleton();
}
return instance;
}
测试类（饿汉式和懒汉式都适用）：
public class Go {
public static void main(String[] args) {
estSingleton t1=TestSingleton.getInstance();
TestSingleton t2=TestSingleton.getInstance();
System.out.println(t1==t2);
}
}
19.override和overlord的区别
1.override是方法的覆盖，overlord是方法的重载
方法名相同，形式参数不同（1.参数个数不同， 2.参数类型不同， 3.参数位置不同）叫重载，和修饰符、返回值无关
子类继承父类，并在子类写一个与父类相同名称的方法叫覆盖
2.方法覆盖override关键字，方法名不能改变
3.方法覆盖子类的作用域范围大于父类
4.方法覆盖子类抛出异常必须遵循两小原则（比父类少，比父类小）
5.被覆盖的方法不能被private修饰
6.被覆盖的方法返回值必须和覆盖的方法一致
20.String、StringBuffer、StringBuilder的区别
1.长度是否固定：String长度不可改变，StringBuffer和StringBuilder长度可改变
2.是否线程安全：StringBuffer线程安全，StringBuilder线程不安全
3.效率：String每次都要在内存中开辟一个新的空间，效率低；StringBuffer和StringBuilder 始终只有一个对象，效率较高
21.判断输出结果
String s1="AAA";
String s2="AAA";
String s3=new String("AAA"); //在内存中开辟一个新的空间
String s4=new String("AAA");
System.out.println(s1==s2); // true
System.out.println(s1==s3); // false
System.out.println(s3==s4); // false
System.out.println(s1.equals(s2)); // true
System.out.println(s2.equals(s3)); // true
System.out.println(s3.equals(s3)); // true
//“==”判断的是内容跟内存地址是否都一致
//equals判断的是内容是否一致
22.String s="aaa";在内存中产生几个对象
String s="aaa";//创建了一个对象
String s1="aaa";String s2="aaa";//还是创建了一个对象
String s="aaa"+"bbb";//还是创建了一个对象，等价于String s="aaabbb";
String s=new String("aaa");//创建了2个对象，一个是aaa，一个是实例对象
23.String与基本数据类型之间的转换
基本数据类型-->String：String.valueOf
String-->基本数据类型：包装类.parseXXX
如：(String-->int：Integer.parseInt)
24.数组和集合的区别
1.长度是否固定：数组长度固定；集合长度可变
2.能否保存映射关系：数组可以保存映射关系：张三---->北京；集合可以map
3.是否可以保存基本数据类型：数组既能保存基本数据类型，也能保存对象；集合可以保存一个对象User，要保存基本类型只能保存包装类
4.是否有方法：数组没有方法；集合有方法
25.ArrayList、Vector和LinkedList的区别
1.线程安全：Vector线程安全；ArrayList线程不安全
2.存储结构：Vector和ArrayList是数组结构；LinkedList是链表结构
3.效率：ArrayList改查快，增删慢；LinkedList改查慢，增删快
26.MyArrayList
public class MyArrayList {
//定义一个数组存储数据
private Object[] data;
//定义大小
private int size;
public MyArrayList(){
data=new Object[10];
}
//实现add方法
public void add(Object obj){
if(size>=data.length){
//扩容
data=Arrays.copyOf(data, data.length*2);
}
data[size++]=obj;
}
//完成扩容
public void ensureCapity(){
//判断是否越界
if(size>=data.length){
//扩容
//1.创建一个新的数组
Object[] newData=new Object[data.length*2];
//2.把原有的数据拷贝到新的数组
for (int i = 0; i < data.length; i++) {
newData[i]=data[i];
}
//把data指向新的数组
data=newData;
}
}
}
27.final修饰类、方法、属性
修饰类：类不能被继承
修饰方法：方法不能被重写（覆盖）
修饰属性：属性变成一个常量，常量不能被更改或重新赋值
28.final修饰属性若要重新赋值
1.直接等于某个值
2.在构造函数中指定
3.在代码块中指定
29.什么是抽象类，什么是抽象方法
被abstract修饰的类是抽象类，被abstract修饰的方法是抽象方法
抽象类可以有抽象方法，也可以有普通方法
抽象方法不能有方法体：pubic abstract void f1();
普通方法可以调用抽象方法
抽象类不能有自己的对象，即不能被new
抽象类中定义的方法需依赖子类实现，定义的抽象方法在子类实现时必须实现抽象类中的全
部方法
abstract能修饰类和方法，不能修饰属性
30.接口和抽象类的异同
共性：两者都不能有自己的实例化对象
区别：抽象类能提供方法的声明，接口不可以
抽象类只能是单继承，接口可多实现
抽象类中定义的变量就是变量，接口中定义的变量是常量
31.HashMap和TreeMap的区别，比较倾向于使用哪一个
一个平衡树的性能是O(logn)。

Java里的TreeMap用一个红黑树来保证key/value的排序。

红黑树是平衡二叉树。

保证二叉树的平衡性，使得插入，删除和查找都比较快，时间复杂度都是
O(log n)。

不过它没有HashMap快，HashMap的时间复杂度是O(1)，但是TreeMap的优点在于它里面键值是排过序的，这样就提供了一些其他的很有用的功能。

使用无序的HashSet和HashMap，还是使用有序的TreeSet和TreeMap，主要取决于你的实
际使用场景，一定程度上还和数据的大小以及运行环境有关。

比较实际的一个原因是，如果插入和更新都比较频繁的话，那么保证元素的有序可以提高快速和频繁查找的性能。

如果对于排序操作（例如产生一个报表合作者运行一个批处理程序）的要求不是很频繁的话，那么把数据以无序的方式存储，然后在需要排序的时候用Collections.sort(?)来进行排序，会比用有序的方式来存储
可能会更加高效。

这个只是一种可选的方式，没人能给你一个确切的答案。

即使是复杂度的理论，
例如O(n)，成立的前提也是在n足够大的情况下。

只要在n足够小的情况下，就算是O(n)的算法也可能会比O（log n)的算法更加高效。

另外，一个算法可能在AMD处理器上的速度比在Intel 处理器上快。

如果你的系统有交换区的话，那么你还要考虑磁盘的性能。

唯一可以确定的性能测
试途径是用大小合适的数据来测试和衡量程序的性能和内存使用量。

在你所选择的硬件上来测试
这两种指标，是最合适的方法。

32.HashMap和HashTable的去呗
1.继承：HashMap：继承于AbstractMap；HashTable：继承于Dictionary
2.线程安全：HashMap线程不安全；HashTable线程不安全
3.null：HashMap允许key和value为null，但key值只能有一个null，否则会覆盖；HashTable 不允许key或value为null
33.final、finally和finalize的区别
final：修饰符（关键字）如果一个类被声明为final，意味着它不再派生出新的子类，不能作
为父类被继承，因此一个类不能既被声明为abstract又被声明为final，将变量或方法声明为final，可以保证它们在使用中不被改变，被声明为final的变量必须在声明时给定初值，而在以后的引
用中只能读取，不可修改，被声明为final的方法也同样只能使用，不能重载
finally：在异常处理时提供finally块来执行任何清除操作，如果抛出一个异常，那么相匹配
的catch语句就会执行，然后控制就会进入finally块
finalize：方法名，Java技术允许使用finalize()方法在垃圾收集器将对象从内存中清除出去之
前做必要的清理工作，这个方法是由垃圾收集器在确定这个对象没有被引用且未删除前对这个对
象进行调用，它是在Object类中定义的，因此所有的类都继承了它，子类覆盖finalize()方法来整理系统资源或者执行其他清理工作。