JavaSE学习笔记(二)：面向对象_以下哪些是java se中的javabean方法标准 getprescription-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_46476301/article/details/123157847

1.学习面向对象的三条主线

一、学习面向对象内容的三条主线
1.Java 类及类的成员：属性、方法、构造器、代码块、内部类
2.面向对象的三大特征：封装、继承、多态性、(抽象性)
3.其它关键字：this、super、static、final、abstract、interface、package、import 等

二、面向对象与面向过程
面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。

面向对象：强调具备了功能的对象，以类／对象为最小单位，考虑谁

2.类与对象的创建与使用

一、设计类、其实就是设计类的成员
   Field = 属性 = 成员变量 = 域、字段
Method = (成员)方法 = 函数
   创建类 = 类的实例化 = 实例化类

二.类和对象的使用(面向对象思想落地的实现)
        1.创建类，设计类的成员
        2.创建类的对象
        3.通过“对象.属性”或“对象.方法”调用对象的结构
三、如果创建类一个类的多个对象，则每个对象都独立的拥有一套类的属性。(非 static的)

四、面向对象中两个重要的概念
类：对一类事物的描述，是抽象的、概念上的定义
对象：是实际存在的该类事物的每个个体，因而也称为实例（
＞面向对象程序设计的重点是类的设计
＞设计类，就是设计类的成员。

堆（Heap），此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。这一点在 Java 虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配。

通常所说的栈（Stack），是指虚拟机栈。虚拟机栈用于存储局部变量等。局部变量表存放了编译期可知长度的各种基本数据类型（boolean、byte、char、short、int、float、long、double）、对象引用（reference 类型，它不等同于对象本身，是对象在堆内存的首地址）。方法执行完，自动释放。

方法区（MethodArea），用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

默认初始化值的情况:

* 属性:类的属性，根据其类型，都有默认初始化值。

* 整型(byte、short、int、long):0

* 浮点型(float、double):0.0

* 字符型(char):0(或‘\u0000’)

* 布尔型(boolean):false

*

* 引用数据类型(类、数组、接口):null

*

* 局部变量:没有默认初始化值

* 意味着:在调用局部变量之前，一定要显式赋值。

* 特别地:形参在调用时,赋值即可。例，45 行

return 关键字后面不可以声明执行语句。

类：抽象的、概念上的内容

对象：实实在在存在的一个个体

二者的关系：

对象是由类new出来

面向对象思想的体现：类和对象的创建和执行操作有哪三步?
①创建类
②类的实例化
③调用对象的结构：“对象、属性”“对象，方法”。

7.方法的重载

1.定义:在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

   “两同一不同”:同一个类、相同方法名
   参数列表不同：参数个数不同，参数类型不同

  2.举例:
   Arrays类中重载的sort() / binarySearch()

  3.判断是否重载
   与方法的返回值类型、权限修饰符、形参变量名、方法体都无关。

  4.在通过对象调用方法时，如何确定某一个指定的方法：
   方法名---》参数列表

8.可变个数的形参

public void show(String ... strs){

}
//此方法与上一方法不可共存
public void show(String[] strs){

}

10.关于变量的赋值

如果变量是基本数据类型，此时赋值的是变量所保存的数据值

如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值

11.

程序设计追求“高内聚，低耦合”。
>高内聚:类的内部数据操作细节自己完成，不允许外部干涉

>低耦合：仅对外暴露少量的方法用于使用。

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

12.

13.封装性的体现，需要权限修饰符来配合

1. Java规定的4种权限(从小到大排列). private、缺省、protected、public
2.4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类
3.具体的，4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
修饰类的话，只能使用：缺省、public

14.构造器的特征和作用

构造器的特征：

>它具有与类相同的名称

>它不声明返回值类型(与声明void不同)

>不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值

构造器的作用:创建对象：给对象进行初始化

一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器

15.

16.JavaBean

·JavaBean是一种Java语言写成的可重用组件。
·所谓javaBean，是指符合如下标准的Java类：
        >类是公共的
        >有一个无参的公共的构造器
        >有属性，且有对应的get、set方法I
·用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。

17.this关键字

1. this可以用来修饰：属性、方法、构造器
2. this修饰属性和方法：
this理解为：当前对象或当前正在创建的对象
2.1在类的方法中，我们可以使用“this.属性”或“this.方法”的方式，调用当前对象属性或方法。但是通常情况下，我们都选择省略”this.”。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用”this.变量”的方式，表明此变量是属性，而非形参。
2.2在类的构造器中，我们可以使用“this.属性”或“this.方法”的方式，调用当前正在创建的对象属性或但是，通常情况下，我们都选择省略“this.”。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显的使用”this.变量“的方式，表明此变量是属性，而非形参。

3. this调用构造器
①我们在类的构造器中,可以显式的使用”this(形参列表)"方式,调用本类中指定的其他构造器
②构造器中不能通过“this(形参列表)"方式调用自己
③如果一个类中有n个构造器，则最多有n-1构造器中使用了"this(形参列表)”
④规定："this(形参列表)"必须声明在当前构造器的首行
构造器内部，最多只能声明一个“this(形参列表)”，用来调用其他的构造器

18. 面向对象的特征之二：继承性

一、继承性的好处：
①减少了代码的冗余，提高了代码的复用性
②便于功能的扩展
③为之后多态性的使用，提供了前提

二、继承性的格式：class A extends B{}
A：子类、派生类、subclass
B：父类、超类、基类、 superclass
2.1体现：一旦子类A维承父类B以后，子类A中就获取了父类B中声明的所有的属性和方法。
特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。只有因为封装性的影响，使得子类不能直接调用父类的结构而已。
2.2子类继承父类以后，还可以声明自己特有的属性或方法，实现功能的拓展。子类和父类的关系，不同于子集和集合的关系。
extends：延展、扩展

三、Java中关于继承性的规定：
1.一个类可以被多个子类继承。
2. Java中类的单继承性：一个类只能有一个父类
3.子父类是相对的概念
4.子类直接继承的父类，称为：直接父类。间接排承的父类称为：间接父类
5.子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法

四、1.如果我们没有显式的声明一个类的父类的话，则此类继承于java. lang. Object类
2.所有的java类(除java. lang. Object类之外)都直接或间接的继承于java. lang. Object类
3.意味着，所有的java类具有java. lang. Object类声明的功能。

19.

方法的重写(override/overwrite)

  1.重写：子类继承父类以后，可以对父类中的方法进行覆盖操作。
  2.应用：重写以后，当创建子类对象以后，通过子类对象去调用子父类中同名同参数方法时，执行的是子类重写父类的方法。
   即在程序执行时，子类的方法将覆盖父类的方法。

  面试题：区分方法的重载与重写(有的书也叫做“覆盖”)
   答：方法的重写Overriding和重载Overloading是Java多态性的不同表现。
   重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。
   如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。
   子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。
   如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。

3.重写的规定：
   方法的声明：权限修饰符返回值类型方法名(形参列表){
   //方法体
   }
   约定俗称:子类中的叫重写的方法，父类中的叫被重写的方法。
   ① 子类重写的方法的方法名和形参列表必须和父类被重写的方法的方法名、形参列表相同;
   ② 子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限,
   特殊情况: 子类不能重写父类中声明为private权限的方法;
   ③ 返回值类型:
   > 父类被重写的方法的返回值类型是void,则子类重写的方法的返回值类型只能是void;
   > 父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类;
   > 父类被重写的方法的返回值类型如果是基本数据类型(比如:double)，则子类重写的方法的返回值类型必须是相同的基本数据类型(必须是:double)。

   ④ 子类方法抛出的异常不能大于父类被重写的方法抛出的异常;

注意：子类与父类中同名同参数的方法必须同时声明为非static的(即为重写)，或者同时声明为static的（不是重写）。
   因为static方法是属于类的，子类无法覆盖父类的方法。

20.

super关键字的使用
  1.super理解为:父类的
  2.super可以用来调用:属性、方法、构造器

  3.super的使用
   3.1 我们可以在子类的方法或构造器中，通过"super.属性"或"super.方法"的方式，显式的调用
   父类中声明的属性或方法。但是，通常情况下，我们习惯去省略这个"super."
   3.2 特殊情况:当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的
   使用"super.属性"的方式，表明调用的是父类中声明的属性。
   3.3 特殊情况:当子类重写了父类中的方法后，我们想在子类的方法中调用父类中被重写的方法时，必须显式的
   使用"super.方法"的方式，表明调用的是父类中被重写的方法。

  4.super调用构造器
   4.1 我们可以在子类的构造器中显式的使用"super(形参列表)"的方式,调用父类中声明的指定的构造器
4.2 "super(形参列表)"的使用，必须声明在子类构造器的首行！
   4.3 我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能二选一，不能同时出现。
   4.4 在构造器的首行，既没有显式的声明"this(形参列表)"或"super(形参列表)",则默认的调用的是父类中的空参构造器。super()
   4.5 在类的多个构造器中，至少有一个类的构造器使用了"super(形参列表)",调用父类中的构造器。

21.面向对象的特征之三：多态性

1.理解多态性:可以理解为一个事物的多种态性。

  2.何为多态性:

   对象的多态性:父类的引用指向子类的对象(或子类的对象赋值给父类的引用)



  3.多态的使用：虚拟方法调用

   有了对象多态性以后，我们在编译期，只能调用父类声明的方法，但在执行期实际执行的是子类重写父类的方法

   简称：编译时，看左边；运行时，看右边。



   若编译时类型和运行时类型不一致，就出现了对象的多态性(Polymorphism)Ø

   多态情况下，

    “看左边”：看的是父类的引用（父类中不具备子类特有的方法）

    “看右边”：看的是子类的对象（实际运行的是子类重写父类的方法）



   4.多态性的使用前提：

    ① 类的继承关系

    ② 方法的重写

   5.对象的多态性:只适用于方法，不适用于基本属性(编译和运行都看左边)

22.向下转型

// 有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法，但是由于变量声明为父类类型，导致

// 编译时，只能调用父类中声明的属性和方法。子类的属性和方法不能调用。

// 如何才能调用子类所特有的属性和方法？

// 使用强制类型转换符，也可称为:向下转型

23. instanceof 关键字的使用

        a instance of A:判断对象a是否是类A的实例。如果是，返回true，如果不是，返回false。
        使用情境，为了避免在向下转型时出现 ClassCastException 的异常，我们在向下转型之前，先进行 instanceof 的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。
        如果a instanceof  A返回true,则a instanceof  B也返回true.其中，类B是类A的父类。

24.

1.若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法，系统将不可能把父类里的方法转移到子类中：编译看左边，运行看右边
2.对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，这个实例变量依然不可能覆盖父类中定义的实例变量：编译运行都看左边

25.==和equals()的区别

一、回顾＝＝的使用(运算符)
1、可以使用在基本数据类型变量和引用数据类型变量中
2、如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。（不一定类型要相同）
如果比较的是引用数据类型变量·比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体充：＝＝符号使用时，必须保证符号左右两边的变量类型一致。
二、equals()方法的使用，
1.是一个方法，而非运算符
2.只能适用于引用数据类型
3. Object类中equals()的定义：
public boolean equals(Object obj){
        return(this==obj);
}
说明，Object类中定义的equals()和E=的作用是相同的。比较两个对象的地址值是否相同，即两个引用是否指
4.像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后，比较的不是两个引用的地址是否相同，而是比较两个对象的“实体内容”是否相同。I

.通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的"实体内容”是否相同。那么，我们就需要对Object类中的equals()进行重写.
重写的原则：比较两个对象的实体内容是否相同

26.Object类中toString()的使用：

1.当我们输出一个对象的引用时，实际上就是调用当前对象的toString()
2. Object类中toString()的定义：
public String toString(){
    return getClass().getName()+"@"+Integer. toHexString (hashCode());
}
3.像String、Date、File、包装类等都重写了Object类中的toString()方法。
使得在调用对象的toString（）时，返回“实体内容”信息

4.自定义类也可以重写toString()方法，当调用此方法时，返回对象的实体内容

27.Java中的JUnit单元测试

步骤：
1.选中当前工程-右键选择，build path-add libraries-JUnit4-下一步

2.创建Java类，进行单元测试。
此时的Java类要求：①此类是public的②此类提供公共的无参的构造器

3.此类中声明单元测试方法。
此时的单元测试方法，方法的权限是public，没有返回值，没有形参
4.此单元测试方法上需要声明注解:@Test,并在单元测试类中导入:import org.junit.Test;
5.声明好单元测试方法以后，就可以在方法体内测试相关的代码。
6.写完代码以后，左键双击单元测试方法名，右键：run as-JUnit Test
说明：
1.如果执行结果没有任何异常：绿条
2.如果执行结果出现异常：红条

28.

29. 包装类与基本类型之间的转换

//基本数据类型 ---> 包装类:调用包装类的构造器


@Test
public void test1(){
    int num1 = 10;

    Integer in1 = new Integer(num1);
    System.out.println(in1.toString());

    Integer in2 = new Integer("123");
    System.out.println(in2.toString());
}

//包装类--->基本数据类型:调用包装类Xxx的xxxValue)()

@Test
public void test2(){
    Integer in1 = new Integer(12);
    
    int i1 = in1.intValue();
    System.out.println(i1 + 1);

    Float f1 = new Float(12, 3);
    float f2 = f1.floatValue();
    System.out.println(f2 + 1);
}

30.自动装箱与自动拆箱(JDK5.0以后才有)

@Test
	public void test3(){
		//自动装箱:基本数据类型--->包装类
		int num2 = 10;
		Integer in1 = num2;//自动装箱
		
		boolean b1 = true;
		Boolean b2 = b1;//自动装箱
		
		//自动拆箱：包装类--->基本数据类型
		System.out.println(in1.toString());
		
		int num3 = in1;//自动拆箱
		
	}

31.

String --->基本数据类型、包装类：调用包装类的parseXxx(String s)

@Test
	public void test5(){
		String str1 = "123";
		
		int num2 = Integer.parseInt(str1);
		System.out.println(num2 + 1);
		
		String str2 = "true1";
		boolean b1 = Boolean.parseBoolean(str2);
		System.out.println(b1);
	}

32.重要面试题！！ (想明白输出结果为何是true 或者 false)

33.static关键字

1. static：静态的

2. static可以用来修饰：属性、方法、代码块、内部类

3.使用static修饰属性：静态变量(或类变量)
        3.1属性，按是否使用static修饰，又分为，静态属性vs非静态属性(实例变量)
                实例变量，我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。
                静态变量，我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。
         3.2 static修饰属性的其他说明。
        ①静态变量随着类的加载而加载。可以通过”类，静态变量“的方式进行调用
        ②静态变量的加载要早于对象的创建。
        ③由于类只会加载一次，则静态变量在内存中也只会存在一份，存在方法区的静态域中。
        ④类变量        实例变量
        类 yes no
对象 yes yes

        3.3静态属性举例：System. out;Math.PI;
4.使用static修饰方法：静态方法
        ①随着类的加载而加载，可以通过＂类，静态方法”的方式进行调用
        ②静态方法        非静态方法
        类 yes no
对象 yes yes
        ③静态方法中，只能调用静态的方法或属性
非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性
5. static注意点：
        5.1在静态的方法内，不能使用this关键字、super关键字)
        5.2关于静态屈性和静态方法的使用，大家都从生命周期的角度去理解。

6.开发中，如何确定一个属性是否要声明为static的?
        ＞属性是可以被多个对象所共享的，不会随着对象的不同而不同的。

        开发中，如何确定一个方法是否要声明为static的？
>操作静态属性的方法，通常设置为static的
>工具类中的方法，习惯上声明为static的。比如：Math、Arrays、 Collections

34.单例(Singleton)设计模式

设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模免去我们自己再思考和摸索。式就像是经典的棋谱，不同的棋局，我们用不同的棋谱，“套路”
所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造器的访问权限设置为private，这样，就不能用new操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象，静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。

单例模式的饿汉式实现(线程已安全版)

class Bank{
    //1.私有化类的构造器
    private Bank(){

    }

    //2.内部创建类的对象
    //4.要求此对象也必须声明为静态的
    private static Bank instance = new Bank();

    //3.提供公共的静态的方法，返回类的对象
    public static Bank getInstance(){
        return instance;
    }
}

单例模式的懒汉式（线程不安全版）（待修改）

class Order{
    //1.私有化类的构造器
    private Order(){
    
    }
    
    //2.声明当前类对象，没有初始化
    //4.此对象也必须声明为static的
    private static Order instance = null;

    //3.声明public、static的放回当前类对象的方法
    public static Order getInstance(){
        if(instance == null){
            instance = new Order();
        }
        return instance;
    }
}

单例模式的懒汉式（线程安全版）

/**
 * 使用同步机制将单例模式中的懒汉式改写为线程安全的
 */
public class BankTest {
}
class Bank{

    private Bank(){}

    private static Bank instance = null;

    public static Bank getInstance(){
        //方式一：效率稍差
        //快捷键:Alt+Shift+Z
//        synchronized (Bank.class) {
//            if(instance == null){
//                instance = new Bank();
//            }
//            return instance;
//        }

        //方式二：效率较高
        if(instance == null) {
            synchronized (Bank.class) {
                if (instance == null) {
                    instance = new Bank();
                }
            }
        }
        return instance;
    }
}

测试

public class SingletonTest1{
    public static void main(String[] args){
        Bank bank1 = Bank.getInstance();
        Bank bank2 = Bank.getInstance();

        System.out.println(bank1 == bank2);
    }
}

34.代码块

代码块分两种：静态代码块和非静态代码块

//静态代码块					
static{
......
}




//非静态代码块
{
......
}

类的成员之四：代码块（或初始化块）
1.代码块的作用：用来初始化类、对象，
2.代码块如果有修饰的话，只能使用static。
3.分类：静态代码块VS非静态代码块

4.静态代码块
＞内部可以有输出语句
＞随着类的加载而执行，而且只执行一次
＞作用：初始化类的信息
＞如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
＞静态代码块的执行要优先于非静态代码块的执行
＞静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构
5.非静态代码块
内部可以有输出语句
随着对象的创建而执行
每创建一个对象，就执行一次非静态代码块
作用：可以在创建对象时，对对象的属性等进行初始化
如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
＞非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法；
I对属性可以赋值的位置：
④默认初始化
②显式初始化
③构造器中初始化
④有了对象以后，可以通过“对象.属性＂或＂对象.方法“的方式，进行赋值
⑤在代码块中赋值

执行的优先级顺序：① - ②/⑤ - ③ - ④

35.final关键字

final：最终的
1. final可以用来修饰的结构：类、方法、变量
2. final用来修饰一个类：此类不能被其他类所继承。
比如：String类、System类、 StringBuffer 类
3. final用来修饰方法；表明此方法不可以被重写
比如:Object类中getClass();
4. final用来修饰变量，此时的“变量”就称为是一个常量
4.1 final修饰属性：可以考虑赋值的位置有：显式初始化、代码块中初始化、构造器中初始化、
4.2 final修饰局部变量：
尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦以后，就只能在方法体内使用此形参，但不能进行重新赋值。

static final用来修饰属性，全局常量I

36.abstract 关键字

abstract关键字的使用
1. abstract：抽象的
2. abstract可以用来修饰的结构；类、方法
3、abstract修饰类：抽象类
此类不能实例化
＞抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）
＞开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作
4. abstract修饰方法：抽象方法
＞抽象方法只有方法的声明，没有方法体
＞包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。
＞若子类重写了父类中的所有的抽象方法后，此子类方可实例化
若子类没有重写父类中的所有的抽象方法，则瓶子类也是一个抽象类，需要使用abstract修饰

abstract使用上的注意点；
1. abstract不能用来修饰：属性、构造器等结构
2. abstract不能用来修饰私有方法、静态方法、final的方法、final的类

37.匿名子类(Person是一个抽象类)

38.

39.接口

接口的使用
1.接口使用interface来定义
2. Java中，接口和类是并列的两个结构
3.如何定义接口：定义接口中的成员
3.1JDK7及以前：只能定义全局常量和抽象方法
>全局常量：public static final的.但是书写时，可以省略不写
>抽象方法：public abstract的
3.2JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法(略)
4.接口中不能定义构造器的!意味着接口不可以实例化I
5. Java开发中，接口通过让类去实现( implements )的方式来使用.如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类

Java类可以实现多个接口--->弥补了Java单继承性的局限性格式:class AA extends BB implements CC,DD,EE
A.接口与接口之间可以继承，而且可以多继承

8，接口的具体使用，体现多态性
9.接口，实际上可以看做是一种规范
面试题：抽象类与接口有哪些异同？

接口的使用
1.接口使用上也满足多态性
2.接口，实际上就是定义了一种规范
3.开发中，体会面向接口编程!

40.java8以后：接口可以有静态方法和默认方法，java7以前只有抽象方法和全局常量

Java8以后：接口可以有静态方法和默认方法

1、接口中定义的静态方法，只能通过接口来调用

2、通过实现类的对象，可以调用接口中的默认方法。如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写的方法

3、如果子类（或实现类）继承的父类和实现的接口中声明了同名同参数的方法，那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法-->类优先原则

4.如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，那么在实现类没有重写此方法的情况下，报错。－－＞接口冲突。这就需要我们必须在实现类中重写此方法

5.如何在子类(或实现类)的方法中调用父类、接口中被重写的方法

//Flyable,Attackable是两个接口方法

接口之间是可以实现多继承的

41.类的内部成员之五；内部类

1. Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类
2.内部类的分类：成员内部类(静态、非静态) vs局部内部类(方法内、代码块内、构造器内)
3.成员内部类：
        一方面，作为外部类的成员：
>调用外部类的结构
                >可以被static修饰
                >可以被4种不同的权限修饰
        另一方面，作为一个类：
        >类内可以定义属性、方法、构造器等>可以被final修饰，表示此类不能被继承。言外之意，不使用final，就可以被继承
                >可以被abstract修饰

4.关注如下的3个问题

》如何实例化成员内部类的对象

》如何在成员内部类中区分调用外部类的结构

》开发中局部内部类的使用