今日课上总结的问题
1. jdk 1 .8关于接口的新特性。
在课上的时候就已经在网上查找了有关JDK1.8的新特性
我简单的总结了一下
JDK1.8中允许存在静态方法，以及两种类型的方法。
还允许存在默认方法，子类重写必须要把default修饰词去掉。
DK8新特性之接口总结
在JDK7以及以前的版本中，接口里的方法都是抽象的，并且不能存在静态方法
所有方法的申名都用 public [返回类型] [方法名](参数列表) [抛出异常];
在jdk8中存在2种类型的方法。
1）静态方法 public static [方法名]([参数列表]) [throws 异常列表]
由于Java中可以同时实现多接口，如果2个接口同时存在同名，同参数的静态方法，如果同子类.静态方法,将不知道访问哪一个。
因此不允许使用【子类.父类静态方法】形式访问,不能通过super方法.
InterA interA = new CImpl();
InterA.method(); //只可以父类名访问静态方法
子类实现多个接口，存在的静态方法并不会冲突。因为只能通过各自父类访问父类静态方法。
public class CImpl implements InterA,InterB
其中InterA InterB存在同名静态方法;甚至子类也可以存在同名方法，但是不能用override修饰，因为static方法不能重写
public static void method(){
System.out.println("子类C中的静态方法");
}
2) JDK8还允许存在默认方法 public default void defaultMethod(){} (default不能省略);
子类重写接口默认方法时，必须去掉default。
@Override
public void defaultMethod(){
System.out.println("子类A中的默认方法，必须去掉default修饰符");
}
子类实现多个接口时，如果存在同名的默认方法，子类将不知道继承哪一个，因此编译器要求子类重写父类中的默认方法；不过注意的事，
子类不能用default修饰，default只能修饰接口中的默认方法。
@Override
public void defaultMethod() {
// TODO Auto-generated method stub
Inter8A.super.defaultMethod();
}
3)优先级的问题
如果一个类继承一个接口的默认方法，同时又继承了另外一个类的方法。
那么子类的方法优先跟父类的方法行为一致.
Inter8A s = new Son();
s.method(); //此处虽然申名是接口类，但是调用子类的方法，而子类的方法跟父类的一致。
2.从内存的角度来说明基本类型数据和引用类型数据的区别
一 基本数据类型
byte：Java中最小的数据类型，在内存中占8位(bit)，即1个字节，取值范围-128~127，默认值0;
short：短整型，在内存中占16位，即2个字节，取值范围-32768~32717，默认值0;
int：整型，用于存储整数，在内在中占32位，即4个字节，取值范围-2147483648~2147483647，默认值0;
long：长整型，在内存中占64位，即8个字节-2^63~2^63-1，默认值0L;
float：浮点型，在内存中占32位，即4个字节，用于存储带小数点的数字（与double的区别在于float类型有效小数点只有6~7位），默认值0;
double：双精度浮点型，用于存储带有小数点的数字，在内存中占64位，即8个字节，默认值0;
char：字符型，用于存储单个字符，占16位，即2个字节，取值范围0~65535，默认值为空;
boolean：布尔类型，占1个字节，用于判断真或假（仅有两个值，即true、false），默认值false;
二 引用数据类型
三 数据类型与内存的关系
四 java中内存分配策略
五 java中的堆和栈
Java的堆是一个运行时数据区,类的(对象从中分配空间。这些对象通过new、newarray、anewarray和multianewarray等指令建立，它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。
抽象类
在某些情况下，父类中只知道子类中应该包含什么样的方法，但是无法知道其具体的实现内容。
抽象方法和抽象类
抽象方法和抽象类都是使用 abstract 修饰的
- 如果在一个类中定义了抽象方法，那么这个类就是抽象类；
- 抽象类是无法实例化的，只能作为父类被继承使用；
- 抽象类的构造器只能用于被实现的子类的构造器调用。
abstract 是不能修饰成员变量的；
如果方法定义为 static，就不能使用 abstract 修饰符；
如果方法定义为 private ，也不能使用 abstract 修饰符；
抽象类：Person.java
package c1103;
public abstract class Person {
private String name;
private String age;
private Boolean sex;
// private abstract void fun1(); // 错误的
// public abstract static void fun2(); // 错误的
public final void eat() {
}
// 此方法为抽象方法
public abstract void talk();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
public Boolean getSex() {
return sex;
}
public void setSex(Boolean sex) {
this.sex = sex;
}
public static void main(String[] args) {
// Person p = new Person(); // 错误的
}
}
实现类：Chinese.java
public class Chinese extends Person{
@Override
public void talk() {
System.out.println("我是中国人，我说汉语。");
}
}
抽象类的作用
抽象类体现的是一种模板模式的设计思想，抽象类作为多个子类的通用模板，子类在抽象的基础上进行扩充，但是子类整体上会保留抽象类的行为方法（必须要实现抽象类的抽象方法）。
抽象类一般只是定义需要使用的方法，把不能实现的部分抽象成抽象方法，留给子类去实现。
父类中可以有实现的方法，但是子类也是可以对已经实现的方法进行改造的（override），但是如果在子类中还需要调用父类的实现方法，可以使用 super 关键字。
最彻底的抽象类：接口
如果在一个类中，一个实现的方法都没有，或者都是抽象方法，那么，这样的类，成为接口。
接口定义使用 interface 定义
语法：
[修饰符] interface 接口名 extends 父接口1, 父接口2... {
0-N 个常量;
0-N个抽象方法;
}
- 接口中所有的成员在定义的时候访问控制修饰符只能是 public 或者是 default；
- 接口的命名规范同类的命名规范；
- 在接口中，成员变量必须是静态的常量，方法必须是抽象方法，所以可以省略相关的修饰符。
接口的继承
接口的继承和类的继承不一样，接口支撑多继承，使用 extends 关键字，之间用逗号隔开，继承的内容包含了，常量和方法
Inter1.java
public interface Inter1 {
static final String C1 = "c1"; // 常量定义的命名规范是全部大写，两个单词之间用 _
void Inter1fun1();
void Inter1fun2();
}
Inter2.java
public interface Inter2 {
static String C2 = "c2"; // 常量定义的命名规范是全部大写，两个单词之间用 _
void Inter2fun1();
void Inter2fun2();
}
Inter3.java
public interface Inter3 extends Inter1, Inter2{
static String C3 = "c3"; // 常量定义的命名规范是全部大写，两个单词之间用 _
void Inter3fun1();
void Inter3fun2();
}
InterImpl.java
public class InterImpl implements Inter3{
@Override
public void Inter1fun1() {
System.out.println("Inter1fun1");
}
@Override
public void Inter1fun2() {
System.out.println("Inter1fun2");
}
@Override
public void Inter2fun1() {
System.out.println("Inter2fun1");
}
@Override
public void Inter2fun2() {
System.out.println("Inter2fun2");
}
@Override
public void Inter3fun1() {
System.out.println("Inter3fun1");
}
@Override
public void Inter3fun2() {
System.out.println("Inter3fun2");
}
public static void main(String[] args) {
InterImpl ii = new InterImpl();
System.out.println(ii.C1);
System.out.println(ii.C2);
System.out.println(ii.C3);
ii.Inter1fun1();
ii.Inter2fun1();
ii.Inter2fun2();
ii.Inter1fun2();
ii.Inter3fun1();
ii.Inter3fun2();
}
}
InterImpl2.java
public class InterImpl2 implements Inter1, Inter2{
@Override
public void Inter2fun1() {
// TODO Auto-generated method stub
}
@Override
public void Inter2fun2() {
// TODO Auto-generated method stub
}
@Override
public void Inter1fun1() {
// TODO Auto-generated method stub
}
@Override
public void Inter1fun2() {
// TODO Auto-generated method stub
}
}
接口的使用
接口是抽象类一样，是不能被实例化的，但是接口可以用于声明引用类型的变量，当使用接口来声明变量时，该变量的运行时类型必须是该接口的实现类。
接口的作用：
- 用于定义实现类的行为规范；
- 定义变量
- 定义一些常量
- 被其他类实现
一个类是可以实现多个接口的，使用 implements 关键字，多个接口之间用逗号隔开。
一个完整的类定义的语法：
在一个 java 文件中，是可以定义多个类的，但是只允许有一个 public 类型的类存在。定义的 public 类型的类必须和文件名一致。
[修饰符：public、final] class 类名 extends 父类 implements 接口1,接口2...{
....
}
接口和抽象类
相同点：
- 都不能被实例化，位于继承树的顶端，是用于被其他类继承或者实现的；
- 都可以包含抽象方法，子类都必须要实现抽象方法；
在实际的开发中，都是接口先行，一般都是先定义接口，然后开发人员实现接口，完成具体方法的实现。
抽象类是个半成品，可以作为一个模板去使用。
不同点：
- 抽象类中可以定义普通方法，但是接口中都是抽象方法和静态变量；
- 在抽象类是可以定义静态方法的，接口中不能定义静态方法的；
- 在抽象中可以定义构造器的，但是在接口中是不存在构造器这个概念的；
- 一个类最多只能有一个直接的父类或者抽象类，但是可以有多个接口的实现。
214
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
