Java 复习总结

Java复习

public，protected，no modifier，private 修饰的属性的访问权限：

自己可以任意访问；
同一个包中，只有private不能访问；
不同的包中，只有子类可以访问protected；

	class	package	subclass(same package)	subclass(different package)	world
public	+	+	+	+	+
protected	+	+	+	+	o
no modifier	+	+	+	o	o
private	+	o	o	o	o

Java面向对象的特征

1.抽象：将现实生活中的对象抽象成属性和行为
2.继承：从现有的类生成新的类的方法，子类继承父类的属性和方法
！！子类可以继承父类所有的属性和方法，但是子类内部或者使用子类的主程序中是否可以访问父类的属性和方法，需要看使用处是否具有访问权限。
3.封装
为私有属性提供访问接口，类中为private属性提供getter and setter方法；
4.多态
允许不同的子类型的对象对同一消息作出不同的响应。分为编译时多态（方法重载）和运行时多态（方法重写），
一.子类继承父类，实现父类的方法，用父类引用子类对象，这样同样的引用调用就会根据子类对象的不同而表现出不同的行为；
二.设计interface，生成不同的类去实现接口，统一访问方式但是表现结果不同。

Java的数据类型

• Java有8大基本类型，数值型 byte，short，int，long，float，double；字符类型char；布尔类型boolean；
  原始类型存储的是值
  每一个基本类型有一个相应的封装类 Byte, Short, Integer, Long, Float, Double, Character, Boolean，应用类中封装了很多实用的方法，e.g. Integer.parseInt() 从java5开始，引入了自动装箱和拆箱机制，使得二者之前可以转换
  int的默认值是0，Integer的默认值是null
• 枚举类型
• 引用类型：任何可实例化的类和数组
  引用类型存储地址

Java虚拟机

• 内存
  堆空间：分配给对象或者JRE类，建立类时会在堆空间建立。当类没有任何引用时，垃圾回收会释放该类所占用的空间。在堆空间建立的类有全局访问权限而且可以被应用中任何地方应用。
  栈空间：在线程运行时使用，包含了method specific values that are short-lived 以及在堆空间的对象的引用，只能被该method引用。栈空间是LIFO的，每当一个方法被调用，会在栈空间为该方法分配一段空间，存储局部变量以及引用，一旦该方法调用结束了，这个区块就会没用了，可以给下一个方法使用。
  栈空间的大小比堆空间小得多。
  静态区：存放常量

构造器是否可以被重写？

构造器不能被继承，因此不能被重写，但可以被重载

String是否可以内继承

不可以，String是final类，不能被继承

String 和 StringBuffer

String可以赋值，StringBuffer只能通过构造函数构造；
String可以用+连接，StringBuffer可以调用append函数连接
String引用的内容不可以被改变的。

重载和重写的区别

重载发生在一个类中，同名的方法有不同的参数列表，返回类型没有要求
重写发生在子类和父类中，重写要求方法有相同的返回类型。

描述一下JVM加载class文件的原理机制。

JVM中类的装载是由类加载器（ClassLoader）和它的子类来实现的，Java中的类加载器是一个重要的Java运行时系统组件，他负责在运行时查找和装入类文件中的类。
由于Java的跨平台性，经过编译的java源程序并不是一个可执行文件，而是类文件，当Java程序需要使用某个类时，JVM会确保这个类已经被加载、连接和初始化。
类的加载是指把类的.class文件中的数据读入到内存中，然后产生与所加载类对应的class对象，然后进行连接和初始化。初始化时，如果有父类还没有被初始化，先初始化父类。

抽象类和接口有什么异同？

• 抽象类和接口都不能实例化，都可以定义它们的引用。一个类如果继承了抽象类或者实现了接口，就需要对其中的抽象方法全部进行实现。
  接口不能定义构造方法，抽象类可以定义；而且接口的方法全部为抽象方法，抽象类中可以有也可以没有抽象方法；接口中的成员全部为public的，抽象类中的成员可以是private，protected，public或者默认的。接口中定义的成员变量实际上都是常量，抽象类中可以定义成员变量；有抽象方法的类必须被声明为抽象类。

什么是GC

垃圾回收，低优先级的线程，不可预知性

类集 Collection接口和Map接口

所有的接口都存放在java.util包中
Collection接口是存放一组单值的最大接口，一般不直接用，有一下几个子接口，支持泛型，泛型不能是基础类型，一定是引用类型
List接口：内容允许重复
Set接口：内容不允许重复，所有重复的内容是靠hashCode()和equals()两个方法区分的
Queue接口：队列
SortedSet接口：单值的排序接口
Map接口：存放一对值的最大接口，key-value的形式
SortedMap: 是Map接口的子接口，存放一对值的排序接口。

List接口的子类——ArrayList

List<String> allList = new ArrayList<String>();
List<String> allList = new ArrayList<>(); //JDK1.7之后可以
//指定操作的泛型为String
allList.add("world");
allList.add(0,"hello");
allList.get(1);
allList.size();
allList.remove(0);
allList.remove("world");
System.out.println(allList);
allList.isEmpty();
allList.indexOf("hello");
allList.contains("world");

List的另一个子类——Vector

和ArrayList差不多，但是是线程安全的。

LinkedList子类与Queue接口

LinkedList表示的是一个链表的操作类，此类定义如下：

public class LinkedList<E> extends AbstractSequentialList<E>implements List<E>,Queue<E>,Cloneable,Serializable

Queue接口是Collection的子接口，此接口的定义如下：

public interface Queue<E> extends Collection<E>

Set接口常用子类——TreeSet，HashSet

Set是不允许重复的

Set<Integer> mySet = new HashSet<>();
mySet.add(3);
mySet.add(1);
mySet.add(1); // will not be added
System.out.println(mySet);

使用add添加了相同对象，set中不会存储重复的对象
HashSet 散列存放
重复对象是如何判断相同的，是根据hashCode（表示一个唯一的编码）和equals（进行对象的比较操作）方法判断的；如果HashSet中需要存放自定义的对象，比如Person对象，那么Person就需要重写这两个方法。

class Person{
 ······
 public boolean equals(Object obj){ //重写该方法，实现对象比较
     if(this == obj){ //同一个对象的引用
         return true;
     }
     if(!obj instanceof(Person)){ //是否是同一个类
              return false;
     }
     Person p = (Person) obj; // 向下转型
     if(this.name.equals(p.name)){
         return true;
     }else{
         return false;
     }
}
public int hashCode(){
    return this.name.hashCode()*this.age; // 定义一个公式
}

通过这两个方法的重写，HashSet才可以进行重复比较和去重。
TreeSet 有序存放
TreeSet中的对象是自动排序的，实际上使通过Comparable接口判断的，常见的Integer,String等类型都实现了Comparable接口;如果HashSet中要存放自定义类型，比如Person对象，这时Person类必须要实现Comparable接口才可以实现排序的功能。

class Person implements Comparable<Person>{ //接口实现
   public int compareTo(Person per){ //自定义比较方法
           ·······      
    }
}

其实，TreeSet也是SortedSet接口的子类。

Iterator接口

是集合输出的标准操作
操作原理：是专门的迭代输出接口，将元素一个一个进行判断，判断是否有内同，如果有就把它取出来。从前向后输出，属于单向操作；
Collection接口中定义了此类实例化的操作 iterator()

Iterator<String> iter = allList.iterator(); // 定义接口的应用，并实例化？
while（iter.hasNext()）{
   System.out.println(iter.next());
}

ListIterator接口

Iterator的子接口，可以实现双向输出。遗憾的是，Collection中没有为此接口实例化的方法，只有List中才有。

public interface ListIterator<E> extends Iterator<E>

可是实现双向输出

ListIterator<String> iter = allList.listIterator();
while(iter.hasNext()){
   System.out.println(iter.next());
}
while(iter.hasPrevious()){
   System.out.println(iter.previous());
}

Map接口

Map接口保存的是一对对象，Map.Entry是 key,value 键值对。

Map接口的子类

HashMap: 无序存放的，是新的操作类，key不允许重复。
Hashtable：无序存放的，是旧的操作类，key不允许重复。性能较低
TreeMap：可以排序的Map集合,按集合中的key排序，key不允许重复。
WeakHashMap: 弱引用的Map集合，当集合中的某些内容不再使用时，可以清除掉无用的数据，可以使用GC进行回收
IdentityHashMap：key可以重复的Map集合

Map接口输出

对于Map接口来说，其本身不能直接使用Iterator,foreach进行输出的，因为Map中的每一个位置存放的是一对值，而Iterator每次只能找到一个值，所以，如果要使用的话，就要：
1，将Map的实例通过entrySet() 方法变为Set接口对象
2，通过Set接口实例为Iterator实例化
3，通过迭代输出，每一个内容都是Map.Entry对象
4，通过Map.Entry进行Key,Value的分离，entry.getKey(),entry.getValue()

直接使用非系统类作为key

必须在此类中重写Object类中的一下两个方法：
hashCode()
equals()

SSH框架

Struts2.0

优点
1，实现了MVC模式，结构清晰
2，有丰富的taglib，提高开发效率
功能
1，包含一个controller servlet,能够将用户的请求发送到相应的Action对象
2，JSP自由tag库，并且在controller servlet中提供关联支持，帮助开发员创建交互式表单应用
3，提供了一系列适用对象：XML处理，通过Java Reflection APIs自动处理JavaBeans属性，国际化的提示和消息。
流程

Hibernate

• 简述
  是一个轻量级的持久层开源框架，它是连接Java应用程序和关系数据库的中间件，负责Java对象和关系数据库之间的映射。
  Hibernate内部对JDBC API进行了封装，负责Java对象的持久化
  他是一种优秀的ORM映射工具
• 缓存
  Session：被称为Hibernate的一级缓存，它存放被当前工作单元加载的对象
  SessionFactory：被称为Hibernate的二级缓存，一个实例对应一个数据存储源。他是线程安全的，是重量级的。他需要一个很大的缓存，用来存放预定于的SQL语句以及映射元数据等。
• 对象的三个状态
  瞬时：一个实体通过new操作创建后，没有和Session建立联系，也没有手动赋值过任何持久化标识，此时该实体中的任何属性的更新都不会反映到数据库表中（没有连接）
  持久化：当一个实体与session创建了联系，并获取了持久化标识，而且在Hibernate的session生命周期内存在，此时针对该实体的任何属性的改变都会直接影响到数据库表中的一条记录对应的字段更新，也即与对应数据库表保持同步（有连接，可同步）
  脱管：当一个实体和Hibernate的session创建了联系，并获取了持久化标识，而此时hibernate的session生命周期结束，实体的持久化标识没有被改动过，针对该实体的任何属性的修改不会反映到数据库中。（没连接，不同步）

Spring

简述：是一个轻量级的容器，非侵入性的框架，最重要的核心概念是IOC（控制反转，DI 依赖注入），并提供AOP慨念的实现方式，提供对持久层，事务的支持。能够减少类之间的依赖性，和程序之间的耦合度，最大程度的实现了松耦合，是程序更加灵活，可扩展性更强。
IOC：我们不必自己在程序代码中维护对象的依赖关系，而是通过一个xml配置文件，将类的属性和实例悄悄注入到类里面，实现类的动态加载，是的类和类之间可以方便的切换。