short s=1;
short s=(short)s+1; 解决方法:强制类型转换;
字符串+(字符串拼接符)任何数据=字符串
举例：System.out.println("5+5="+5+5); //"5+5=55"
switch语句中:恰当使用 case穿透;
while循环和for循环的区别:
1)如果从内存角度考虑:
for循环要优于while循环,for循环语句执行完毕之后,变量会及时被GC垃圾回收期回收掉
while循环,它可以去访问循环语句中的变量
2)根据具体需求具体分析:
如果循环次数明确的情况下,应用for循环
如果不知道要循环多少次,应该去使用while循环
使用数组时小心下标越界:ArrayIndexOutOfBoundsException:数组角标越界异常
解决方案:观察数组中到底有索引值到多少; 数组长度-1
面向对象思想的特征:
1)面向对象更符合我们的生活中的行为思想习惯
2)面向对象将我们从执行者变成了指挥者,指挥对象做事情
3)面向对象简单性体现在这里:让我们做的事情从复杂性--->简单化
关于static关键字:
1)静态随着类的加载而加载
2)static优先于对象存在
回想:main public static void main(..){...}
3)static共享数据,可以被多个对象进行共享
举例: 饮水机(staticd的:共享的)
水杯(不能共享的...)
4)如果数据被静态修饰的,它可以被类名直接调用
被静态修饰的方法: 类名.方法名()
被静态修饰的变量: 类名.变量名;
关于代码块的概述：
用{}括起来的代码，统称为代码块；
根据其位置以及声明不同：分为以下:
局部代码块：在main()里面,给变量限定它的生命周期；
构造代码块：在一个类中的成员位置中,用{}括起来；
作用：可以将多个构造方法中的相同的代码放到构造代码块中,对对象进行初始化. 在每次执行构造方法
之前,先执行构造代码块；
静态代码块：在一个类的成员位置,也是用{}包起来,但是他被static修饰；
作用：一般情况 它的作用给类进行初始化；
1)在类中位置不同
成员变量:类中，方法外；
局部变量:方法声明上，或者再方法定义中；
2)在内存中的位置不同
成员变量:堆内存；
局部变量:栈内存；
3)生命周期不同
成员变量:成员变量是随着类的加载而加载，随着类的消失而消失；
局部变量:随着方法的调用而存在，随着方法调用完毕而消失；
4)初始化值不同
成员变量:初始化由系统默认初始化，对于成员变量，可以不给初始化值,由系统给，然后显示初始化；
局部变量:定义一个局部变量，必须进行初始化，如果不初始化，无法使用(在使用之前进行初始化) ；
this:代表是当前类对象,或者是(当前类对象的引用),解决局部隐藏了成员变量
多态的前提:
1)必须有继承关系
子类继承父类,存在一些特点
2)必须有方法重写
子类继承父类,方法重写的目的,举例:动物吃的方法,每一个具体动物吃的东西不一样,所有必须要方法覆盖
3)就是必须有父类的引用指向子类对象 (向上转型)
父类名 fu = new 子类名() ; (父类的引用指向子类对象)
多态中的成员访问特点:
1)成员变量: 编译看左,运行看左...
2)成员方法(非静态): 编译看左,运行看右(存在方法重写)
3)构造方法:构造方法(无论子类,还是父类),都是对对象进行初始化
4)静态成员方法: 编译看左,运行看左(静态跟类有关系,算不上方法重写)
要点：多态中,访问父类子类都有的非静态方法,那么运行结果看子类;
访问父类子类都有的静态方法,那么运行结果看父类;
多态的前提之一有,方法重写,那么不能访问子类的特有的方法;
多态的好处:
可以提供代码的复用性:继承保证
可以提高的代码的扩展性:由多态保证
多态的弊端:通过父类的引用调用子类特有功能,不能调用
解决:将父类的引用强制转换子类的引用 (访问子类的特有功能)
举例:Father3 f = new Son3() ;//向上转型
Son3 s = (Son3) f ; //前提是必须有父类的引用
将父类的引用强制转换子类的引用 ,向下转型使用不当,会出现一个异常:属于运行时期异常:ClassCastException
this和super关键字的用法:
成员变量:
this:this.成员变量; (访问当前类)
super:super.成员变量;(访问父类)
构造方法:
this(); //无参构造
this("") ;//访问当前类的有参构造
super()://访问的父类的无参构造
super("")://访问的是父类的有参构造..
成员方法:
this.xx()
super.xx()
关于this和super的区别?
this:代表当前类的对象
super:代表父类空间标识,理解为代表父类的对象
成员变量
this.成员变量
super.成员变量
成员方法
this.成员方法()
super.成员方法();
构造方法
this()/this("..")
super()/super("...");
当子类中的成员方名和父类中的成员方法名一致的情况:
1)现在子类的成员位置找,如果有就调用
2)如果没有找到,在父类的成员位置找,有就调用
关于代码块的概述:用{}括起来的代码,统称为代码块;
根据其位置以及声明不同:分为以下:
局部代码块: 在main()里面,给变量限定它的生命周期
构造代码块:在一个类中的成员位置中,用{}括起来,
作用:可以将多个构造方法中的相同的代码放到构造代码块中,对对象进行初始化. 在每次执行构造方法之前,先执行构造代码块.
静态代码块:在一个类的成员位置,也是用{}包起来,但是他被static修饰
作用:一般情况 它的作用给类进行初始化
构造代码块,构造方法,静态代码的优先级?
答案:静态代码块>构造代码块>构造方法
静态代码:只能执行一次
构造代码块在每次执行构造方法之前都会被执行
overload和override的区别?
overload:方法重载(方法名一样,参数不同,和返回值没有关系)
参数不同:
1)参数个数不同
2)参数类型不同
override:方法重写 (子类定义一个和父类一摸一样的方法声明)
接口:体现的是事务的扩展性功能(额外动作,后天经过学习等等)
接口成员的特点:
成员变量:是一个常量,不能更改,并且默认的修饰符
public static final:
构造方法:接口不存在构造方法
成员方法:都是抽象方法
默认的修饰符:public abstract
接口和接口之间的关系:继承关系;
类和类之间的关系:继承关系
类和接口之间的关系:实现关系
静态成员内部类访问外部类的数据,该数据必须static修饰
内部类被static修饰 ==> Outer.Inner oi=new Outer.Inner();
多态(方法重写):父类和子类都有方法实现;
抽象类(abstract):子类必须实现父类中的抽象方法,并且子类不能是抽象类,没有意义(不能实例化);
A)成员的区别:
成员变量:
抽象类:既可以常量,也可以是变量
接口:只能是常量,默认的修饰符:public static final
构造方法:
抽象类:有构造方法,无参/有参 (给对象进行初始化的)
接口:没有构造方法
成员方法:
抽象类:可以有抽象方法,也可以有非抽象方法
接口:只能是抽象方法 :默认的修饰符:public abstract
B)类与类/类与接口关系的区别:
类与类之间的关系:
继承关系,只支持单继承,不支持多继承,但是可以多层继承
类与接口的关系:
实现关系,一个类继承另一个类的同时,还可以实现多个接口...
接口与接口的关系:
是一种继承关系,既可以单继承,也可以多继承...
接口1 extends 接口2,接口3...
C)设计原则的 区别
1)抽象类: 是有继承关系---->体现的是一种"is a"的关系 (A是B的一种或者B是A的一种)
2)接口:类和接口:实现关系--->体现的是一种" like a"的关系(扩展功能) :跳高猫 像猫
匿名内部类的本质:
是继承了该类或者实现了该接口子类对象
Object：是类层次结构的根类.每个类都使用 Object 作为超类(父类)
键盘输入数据：先输入int类型，再输入String类型，会有问题；
解决：重新创建一个键盘输入对象
String最大的特点：字符串一旦被赋值,其值不能改变；
原因：直接把一个常量赋值给String类型，这种形式，它是在方法去中的字符串常量池中看有没有当前字符串，有直接返回它的地址，没有就在常量池中开辟空间；
StringBuffer和String的区别?
前者是一个可变的字符序列,后者是不可变的字符序列
如果从内存角度考虑,String定义的时候,会在常量池中开辟空间,比较耗费内存
而StringBuffer,字符串缓冲区(里面存储的全部都是字符串),它会释放掉
StringBuffer,String,StringBuilder的区别?
StringBuffer和StringBuilder都是一个可变的字符序列,提供一个缓冲区.(两者都看做容器)
StringBuffer:线程安全的,同步的,执行效率低
StringBuilder:线程不安全的,不同步的,执行效率高,并且单线程中优先采用StringBuilder
StringBuffer 执行效率虽然低,但是优于String类型,并且他是一个可变的字符序列,提供了缓冲区
StringBuffer和数组的区别?
数组:它是可以存储多个数据的容器,并且多个数据的类型必须一致
数组长度功能:length属性
StringBuffer:它是容器,它在缓冲区始终存储的只能字符串类型的数据
获取缓冲区的长度:length()
Calendar 类是一个抽象类(不能实例化)，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法
Calendar类：这个类使用Calendar . MONTH，输出的时候需要加1，才是需要的月份，MONTH是从0开始计算的；
Date和String之间的相互转换：
1> Date date=new Date();
String s=new SimpleDateFormat("yyyy-MM-dd").format(date);
2> String ss="2323-2-22";
Date d=new SimpleDateFormat("yyyy-MM-dd").parse(ss);
数组和集合的区别?
1)长度区别:
数组长度固定
集合长度可变
2)内容的区别
数组可以存储同一种类型的元素
集合可以存储多种类型的元素
3)存储类型的区别
数组:可以存储基本类型,也可以存储引用类型 String[] str = {"hello","world","java",100} ; 错误的
集合:只能存储引用类型
集合Collection中的removeAll()：
c1.removeAll(c2)：删除集合c2中的所有元素，并将删除元素后的集合赋给c1，但是集合c2中的元素不发生变化；
c1.containsAll(c2)：集合c2中的所有元素都要在c1中能找到才算包含全部；
c1.retainAll(c2)：c1集合对c2集合取交集,交集的元素要存到c1集合中,boolean返回值表达的c1集合的元素是否发生变化,如果发生变化,则返回true,否则,返回false；
java.util.ConcurrentModificationException：当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常；
原因：按照正常的需求,给集合添加元素,遍历,遍历同时,判断集合中是否有需要的元素,有就添加新元素，遍历的时候,使用迭代器遍历,但是添加元素,使用集合添加元素.集合添加了一个新的元素,迭代器不知道；
解决方案：
方式1：要么使用List集合的特有迭代器遍历,使用迭代器添加元素!
方式2：要么使用集合遍历,使用集合添加元素!
List集合有三个子实现类:
ArrayList：
1>底层数据结构式数组结构,查询块,增删慢
2>从内存角度考虑:线程不安全的,不同步的,执行效率高
3>多线程:synchronized :同步的意思 解决线程安全问题
sychronized(锁对象){ 同步代码
共享数据;
}
4>解决线程安全问题,通过同步可以解决,但是效率低了...
LinkedList：
1>底层数据结构式链表结构,查询慢,增删块
2>从内存角度考虑:线程不安全,不同步,执行效率高
Vector：
1>这是一个线程安全的类,底层数据结构是数组:查询快,增删慢
2>线程安全的,同步,执行效率低!
泛型的好处：
1)将运行时期异常提前到了编译时期；
2)优化了设计,解决了黄色警告线问题；
3)避免了强制类型转换；
泛型的应用：在接口中，类中，方法上应用，在集合中应用最多；
Set集合和List集合的区别?
Set集合：不允许元素重复，唯一的(元素可以为null) ，不能保证迭代的顺序恒久不变(底层哈希表和hascode)；
无序(存储和取出不一致)；
List：允许元素重复，并且存储特点:有序性(存储和取出一致)；
解决：在Student类中重写这两个方法；
如果在开发中，元素唯一性，并且还要保证元素有序(存储和取出一致)，使用LinkedHashSet集合；
LinkedHashSet集合：
底层是一种链接列表和哈希表组成；
可以保证元素的唯一性，是由哈希表决定的(hashCode()和equals())；
可以保证元素的迭代顺序一致(有序)，存储和取出一致，是由链表决定；
TreeSet集合模拟情况下是通过自然顺序对集合中的元素排序；
可以保证元素唯一并且元素排序(Integer类型的元素自然升序)；
分为：自然排序 比较器排序；
TreeSet集合排序：
自然排序：
在定义的类继承Comparable接口，重写其中的compareTo()方法；
选择排序：
使用匿名内部类方式，在TreeSet<Student>()的括号中new Comparator,并重写方法compare方法；
HashMap集合本身基于哈希表：
它可以保证键的唯一性(Map都是针对键有效)；
HashMap集合：
如果成员变量的值一样，认为是同一个数据；
HashMap底层是哈希表：依赖于hashCode()，equals()；
如果集合的健一样，值不一样，那么后边的值会将前面的值替换掉；
LinkedHashMap<K,V>：是Map接口基于哈希表和链接列表实现的；
哈希表：保证键的唯一性；
链接列表：保证元素有序性(存储和取出一致)；
TreeMap集合也可以进行自然排序，比较器排序；
面试题：
HashMap集合和Hashtable的区别?；
共同点：都是map接口的实现类，都是基于哈希表的实现类；
HashMap集合线程不安全的类，不同步，执行效率高(允许键和值是null的)；
Hashtable集合线程安全的类，同步，执行效率低(不允许有null键和null值) ；
Collection和Collections的区别：
Collection：顶层次单列集合的根接口，它是一个集合，是一个接口；
Collections：是针对集合操作的工具类，有一些功能:随机置换，集合里面的二分查找，将集合的元素进行反转；
异常：
编译时期异常：只要出现的不是运行时期异常，统称为编译时期 ；
编译时期异常：开发者必须处理!
运行时期异常：RuntimeException；
编译通过了，但是开发者代码不严谨(NullPointerExceptino等等...)；
编译时期异常和运行时期异常的区别?
编译时期：开发者必须进行显示处理，不处理，编译不能通过；
运行时期异常：无需进行显示处理，可以像编译时期一样进行处理；
throw关键字通常用于方法体中，并且跑出一个异常对象；
程序在执行到throw语句是立即停止，它后面的语句都不执行；
如果throw抛出异常后，如果想在上一级代码中捕获并处理异常，则需要在抛出异常的方法中使用throws关键字在方法的声明中也要抛出异常；
如果要捕捉throw抛出的异常，则必须使用try-catch语句块；
throws和throw的区别?
throws：也是表示抛出异常，它后面跟的异常类名，并且可以多个异常类名中间逗号开；
举例:
public void show() throws IoException,ClassNotFoundException{...}
在方法上抛出，由调用者处理；
它表示抛出异常的可能性；
throw：抛出的一个异常对象；
在语句体中抛出的，由语句体进行处理；
它表示抛出异常的肯定性；
如果catch里面有return 语句，finally中的代码还会执行，是在return语句之前执行还是return后执行?
解决：finally中代码是一定会执行的，是在return前；
异常中的注意事项：
子类继承父类的时候的注意事项
1> 子类重写父类的方法的时候,子类的方法的抛出的异常必须要么是父类的方法异常一样,要么是父类方法异常的子类
2> 子类重写父类方法的时候,如果父类中的这个方法没有抛出异常,那么子类重写的这个方法也不能抛出异常,只能try...catch
File类：表示文件或者目录的路径的抽象表现形式；
Runnable接口的目的是为希望在活动时执行代码的对象提供一个公共协议；
所以在这个类中的成员变量已经被共享,因此不需要给变量添加static；
同步代码块：synchronized(锁对象){
针对多条语句对共享数据操作代码；
}
校验一个多线程程序是否有安全问题的隐患的前提条件：
1)当前程序是否是多线程环境 (不能解决)
2)是否有共享数据 (不能解决)
3)是否有多条语句对共享数据进行操作 (同步代码块)
注意:
锁对象:一定要同一个锁(每个线程只能使用同一把锁)
锁对象:任何的Java类(引用类型)
线程安全的类:
StringBuffer sb = new StringBuffer() ;
Vector<String> v = new Vector<String>() ;
Hashtable<String, String> hm = new Hashtable<String,String>() ;
静态同步方法的锁对象:类名.class
非静态的方法锁对象:this
两个或两个以上的线程,在执行的过程中出现互相等待的情况,就叫做死锁
wait(),notify(),notifyAll() 这些方法为什么会定义在Object类中呢?
定义在Object类中的原因:这些方法好像是属于线程的方法,但是Thread类中并没有这些方法,
因为多线程中同步锁对象是任意的Java类,而这些方法都和锁对象有关系,所以定义在Object类;
wait()和sleep(long times) 的区别?
1>这两个方法来自不同的类分别是 Object 和 Thread;
2>最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法(锁代码块和方法锁)
3>wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用(使用范围)
4>sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常
线程池:多个线程执行完毕,它会重新回到线程池中,等待被利用,不会变成垃圾!
特点:1)节约成本;
2)线程执行完毕之后不会变成垃圾,重新回到线程池中,等待被利用;
多线程实现方式第三种:
前提:自定义类实现Callable接口
1)创建线程池对象: Executors 里面的那个方法newFixedThreadPool(),返回的是ExecutorsService
2)然后调用ExecutorsService里面的提交任务的方法:
<T> Future<T> submit(Callable<T> task)提交一个返回值的任务用于执行
Future:表示计算结果;
3)关闭线程池