day07 Java基础

一、关于Java的抽象类、接口，

1. 抽象类不一定含有抽象方法，接口中的方法都是抽象方法。接口中的方法默认修饰符有public abstract。
2. 一个类只能继承一个一个抽象类，但可以实现多个接口；一个接口可以继承多个接口。Java里类是单继承的，接口是可以多继承的，用关键字extends。
3. 抽象类和接口中的方法都没有方法体（描述错误的）。 抽象类中的方法是可以有方法体的。JDK1.8之后，接口中的方法也可以有方法体，用default关键字修饰方法。
4. 抽象类可以含有私有成员变量，接口不含有私有成员变量。 接口中的成员变量都是public static final的，一般用作常量

二、关于依赖注入：
依赖注入能够独立开发各组件，然后根据组件间关系进行组装
依赖注入提供使用接口编程
依赖注入指对象在使用时动态注入
三、抽象类中的抽象方法不能带有方法体；一旦使用了{}就是有方法体，尽管方法体内部是空的
四、String s = new String(“xyz”);创建了几个StringObject？
1.String对象的两种创建方式:
第一种方式: String str1 = “aaa”; 是在常量池中获取对象(“aaa” 属于字符串字面量，因此编译时期会在常量池中创建一个字符串对象)，
第二种方式: String str2 = new String(“aaa”) ; 一共会创建两个字符串对象一个在堆中，一个在常量池中（前提是常量池中还没有 “aaa” 字符串对象）。

System.out.println(str1==str2);//false

2.String类型的常量池比较特殊。它的主要使用方法有两种：
直接使用双引号声明出来的String对象会直接存储在常量池中。
如果不是用双引号声明的String对象,可以使用 String 提供的 intern 方法。 String.intern() 是一个 Native 方法，它的作用是： 如果运行时常量池中已经包含一个等于此 String 对象内容的字符串，则返回常量池中该字符串的引用； 如果没有，则在常量池中创建与此 String 内容相同的字符串，并返回常量池中创建的字符串的引用。

String s1 = new String("AAA");
String s2 = s1.intern();
String s3 = "AAA";
System.out.println(s2);//AAA
System.out.println(s1 == s2);//false，因为一个是堆内存中的String对象一个是常量池中的String对象，
System.out.println(s2 == s3);//true， s2,s3指向常量池中的”AAA“

五、面向对象的五个基本原则：
s( Single-Resposibility Principle ): 单一职责原则
o( Open-Closed principle ): 开放封闭原则
l( Liskov-Substituion Principle ): 里氏原则
i( Interface-Segregation Principle ): 接口隔离原则
d( Dependecy-Inversion Principle ): 依赖倒置原则
一个单词：立方体(solid),很好记!!!

具体描述：
单一职责原则（Single-Resposibility Principle）：一个类，最好只做一件事，只有一个引起它的变化。单一职责原则可以看做是低耦合、高内聚在面向对象原则上的引申，将职责定义为引起变化的原因，以提高内聚性来减少引起变化的原因。
开放封闭原则（Open-Closed principle）：软件实体应该是可扩展的，而不可修改的。也就是，对扩展开放，对修改封闭的。
Liskov替换原则（Liskov-Substituion Principle）：子类必须能够替换其基类。这一思想体现为对继承机制的约束规范，只有子类能够替换基类时，才能保证系统在运行期内识别子类，这是保证继承复用的基础。
依赖倒置原则（Dependecy-Inversion Principle）：依赖于抽象。具体而言就是高层模块不依赖于底层模块，二者都同依赖于抽象；抽象不依赖于具体，具体依赖于抽象。
接口隔离原则（Interface-Segregation Principle）：使用多个小的专门的接口，而不要使用一个大的总接口
六、Math函数
ceil：大于等于 x，并且与它最接近的整数。
floor：小于等于 x，且与 x 最接近的整数。
计算余弦值使用Math类的cos()方法
toRadians()是将角度转换为弧度
toDegrees()是将弧度转换为角度
七、在 Java 中，Java中的四类八种基本数据类型:
第一类：整数类型 byte short int long
第二类：浮点型 float double
第三类：逻辑型 boolean(它只有两个值可取true false)
第四类：字符型 char
八、运行结果：由于String s没有初始化，代码不能编译通过。
类中实例变量可以不用初始化，使用相应类型的默认值即可；方法中的定义的局部变量必须初始化，否则编译不通过。

public static void main(String[] args){
    String s;
    System.out.println("s="+s);
}

九、运算符优先级

boolean b=true?false:true==true?false:true;
System.out.println(b);

解析：
== 优先级高于 三目运算符，先判断 true == true，此时返回为 true,
这时表达式为 boolean b = true?false:true?false:true
此时三目运算符从右向左执行,true?false:true，返回false
这时表达式为 boolean b = true?false:false;
结果为：boolean b = false ;
十、

Integer i = 42; 
Long l = 42l; 
Double d = 42.0; 

1、基本型和基本型封装型进行“==”运算符的比较，基本型封装型将会自动拆箱变为基本型后再进行比较，因此Integer(0)会自动拆箱为int类型再进行比较，显然返回true；

     int a = 220;

     Integer b = 220;

    System.out.println(a==b);//true

2、两个Integer类型进行“==”比较， 如果其值在-128至127 ，那么返回true，否则返回false, 这跟Integer.valueOf()的缓冲对象有关，这里不进行赘述。

    Integer c=3;
    Integer h=3;
    Integer e=321;
    Integer f=321;
    System.out.println(c==h);//true
    System.out.println(e==f);//false

3、两个基本型的封装型进行equals()比较，首先equals()会比较类型，如果类型相同，则继续比较值，如果值也相同，返回true。

    Integer a=1;
    Integer b=2;
    Integer c=3;
    System.out.println(c.equals(a+b));//true

4、基本型封装类型调用equals(),但是参数是基本类型，这时候，先会进行自动装箱，基本型转换为其封装类型，再进行3中的比较。

    int i=1;
    int j = 2;
    Integer c=3;
    System.out.println(c.equals(i+j));//true

十一、ResultSet中记录行的索引下标：
ResultSet跟普通的数组不同，索引从1开始而不是从0开始。
十二、对象创建方法中会调用构造方法的是：
new语句创建对象；
java反射机制使用java.lang.Class或java.lang.reflect.Constructor的newInstance()方法
十三、关于jsp生命周期：
JSP会先解释成Servlet源文件，然后编译成Servlet类文件。
Jsp只会在客户端第一次发请求的时候被编译，之后的请求不会再编译，同时tomcat能自动检测jsp变更与否，变更则再进行编译。

第一次编译并初始化时调用： init() ；销毁调用： destroy() 。在整个jsp生命周期中均只调用一次。

service()方法是接收请求，返回响应的方法。每次请求都执行一次，该方法被HttpServlet封装为doGet和doPost方法。
十四、
Java中的类型转换：

byte b = 1;
char c = 1;
short s = 1;
int i = 1;

// 三目，一边为byte另一边为char，结果为int
// 其它情况结果为两边中范围大的。适用包装类型
i = true ? b : c; // int
b = true ? b : b; // byte
s = true ? b : s; // short

// 表达式，两边为byte,short,char，结果为int型
// 其它情况结果为两边中范围大的。适用包装类型
i = b + c; // int
i = b + b; // int
i = b + s; // int

// 当 a 为基本数据类型时，a += b，相当于 a = (a) (a + b)
// 当 a 为包装类型时， a += b 就是 a = a + b
b += s; // 没问题
c += i; // 没问题

// 常量任君搞，long以上不能越
b = (char) 1 + (short) 1 + (int) 1; // 没问题
// i = (long) 1 // 错误