来黑马程序员之后的部分纠错点：
1.关于常量的打印输出，下列哪个选项是正确的？（ A）
A：
System.out.println("");
B：
System.out.println('');
C：
System.out.println(null);
D：
System.out.println('ab');
答案解析：
A选项：该选项正确，空字符串常量可以通过打印语句输出。
B选项：该选项错误，字符常量，在单引号之间有且仅有一个字符。
C选项：该选项错误，空常量，不能使用打印语句输出。
D选项：该选项错误，字符常量，在单引号之间有且仅有一个字符，且不能为空。
2.下列代码的运行结果是（B ）
public static void main(String[] args){
    int x = 3;
    float y = x;
    System.out.println(y);     //错选为C
}
A.3    B.3.0   C.3.0F   D.3F
float是浮点数类型，需要显示出浮点数类型的结果，控制台当中不会出现F作为后缀
A选项：该选项错误，3的数据值是错误的，结果是float类型，需要显示浮点数结果，应该是3.0
B选项：该选项正确，3.0的数据值是正确的，结果是float类型，需要在末尾加上.0 表示浮点数
C选项：该选项错误，3.0F 控制台不能显示出后缀F，后缀F是为了区分单精度float和双精度double的书面写法
D选项：该选项错误，输出结果不会显示字母F，因为字母F只在定义Float类型变量使用，如果float类型变量初始值是整数，打印结果时后面加.0
3.一旦JDK的环境变量配置完成，就可以在任意目录下执行jdk给我们提供的相关命令。
4.public class Test4{
public static void main(String[] args){
         int a=10;
   System.out.println(a);
   a=a+10;
   
  System.out.println(a);
   short i=10;
    i=(short)(i+10);
   System.out.println(i);
        }
}
5.字符串常量：                用双引号括起来的内容。"HelloWorld","黑马程序员"
整数常量：                不带小数的数字。666, -88
小数常量：                带小数的数字。13.14, -5.21
字符常量：                用单引号括起来的内容。'A','0','我'
布尔常量：                布尔值，表示真假。只有两个值：true,false
空常量：                        一个特殊的值，空值，null（null值可以直接在输出语句打印吗？）
6.
在主方法中通过键盘录入三个整数。定义一个方法，方法接收三个整数变量，在方法中从大到小依次打印三个变量。执行效果如下：
请输入第一个整数：10
请输入第二个整数：30
请输入第三个整数：20
从大到小的顺序是： 30 20 10
1）方法一：
import java.util.Scanner;

public class demo1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个整数：");
        int number1 = sc.nextInt();
        System.out.println("请输入第二个整数：");
        int number2 = sc.nextInt();
        System.out.println("请输入第三个整数：");
        int number3 = sc.nextInt();
        get(number1,number2,number3);
    }


        public static void get(int number1,int number2,int number3 ){
             int temp=number1>number2?number1:number2;
             int max=temp>number3?temp:number3;
             int temp1=number1<number2?number1:number2;
             int min=temp1<number3?temp1:number3;

             int mid=number1+number2+number3-max-min;
            System.out.println("从大到小的顺序为："+max+","+mid+","+min);
        }
    }
2）方法二：
  public static void get(int number1,int number2,int number3 ){
             int temp=number1>number2?number1:number2;
             int max=temp>number3?temp:number3;
             int temp1=number1<number2?number1:number2;
             int min=temp1<number3?temp1:number3;

             int mid=number1+number2+number3-max-min;
            System.out.println("从大到小的顺序为："+max+","+mid+","+min);
        }
    }
6. 
A选项：该选项正确，使用面向对象的编程思想完成一个功能，需要找到一个能够完成该功能的对象，使用这个对象完成该功能，那么这个对象完成这个功能时需要一个步骤一个步骤的去完成，所以说面向对象是一种基于面向过程的编程思想。
B选项：该选项正确，使用面向对象编程思想完成一个功能，只要找到能完成该功能的对象，使用这个对象完成该功能即可，不需要关心过程中的每一个步骤。
C选项：该选项错误，王经理在完成修车这个功能时，每一个步骤都是自己亲力亲为，所以体现的是面向过程的编程思想。

D选项：该选项正确，小明在完成修电脑这个功能时，并没有亲力亲为，而是找会修电脑的师傅帮他完成，所以体现了面向对象的编程思想。
7.

面向对象思想,关注的是对象,让对象完成一个功能,我们关注的是结果而不是功能的每一个步骤!
生活中有很多面向对象思想的例子：
举例:洗衣服
面向过程：把衣服脱下来-->找一个盆-->放点洗衣粉-->加点水-->浸泡10分钟-->揉一揉-->清洗衣服-->拧干-->晾起来 
面向对象：把衣服脱下来-->打开全自动洗衣机-->扔衣服-->按钮-->晾起来
面向过程：强调步骤。
面向对象：强调对象，这里的对象就是洗衣机。
8.代码如下，下列关于数组的反转描述正确的是（ ）
public static void main(String[] args) {
    int[] array = { 10, 20, 30, 40, 50 };
    for (int min = 0, max = array.length - 1; min < max; min++, max--) {
        int temp = array[min];
        array[min] = array[max];
        array[max] = temp;
    }
}
9.public int add(int a, int b)
{
int c = a + b;
return c;
System.out.println(c);
该选项考察方法中return语句执行流程的问题，一旦执行到return语句，后面的内容将不会执行，如果return语句后面具有必定会执行的其他语句，程序会编译失败。





学习笔记：
-----------------Day4-------------------------------------
1.项目--》模块module--》package包--》class类
2.psvm回车--快速生成main方法
   sout回车-- 快速生成输出语句
  ctrl+alt+空格-----内容辅助代码补全
   Ctrl+/ 单行注释
   ctrl+shift+/  多行注释
3.数组的定义格式：
（1）数据类型【】数组名    int【】arr；（最好用该种方式）double[ ] arr;
（2）数据类型 数组名【】   int arr【】;

4.不同数据类型系统给的默认值不同：
    byte short int long------》0
    float double         -------》0.0
    boolean               ------->false
    char---------------->' '
    String ------------>null
5.数组的静态初始化;
   格式1：int[ ] arr=new int[ ]{1,2,3};
   格式2：int [ ]arr={1,2,3};(两者均可，2较为常用)
--------------------Day5------------------------------
!!!!!!!!!!!------面试之重：方法重载
1.方法使用 的注意事项：必须先定义再调用。
2.形参：定义方法时的参数
   实参：调用方法时的参数
3.void表示无返回值，可以省略return，也可以单独书写return，后面不加数据。
--------------------Day7-------------------------------
1.this关键字
this修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）
方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
方法的形参如果没有与其同名，不带this修饰的变量指的是成员变量。
2.构造方法
  格式：修饰符 类名（参数）{
}
修饰符一般是public（无返回值类型，即无void）
构造方法在创建对象的时候调用执行 eg:Student s=new Student();
1）构造方法与类同名，支持重载
2）可以使用有参构造方法，对成员变量进行赋值，达到初始化数据的效果
3）如果没有定义构造方法，系统会给出一个默认的无参数构造方法，如果定义了构造方法，系统将不再提供默认的构造方法。  
4）只能在通过new实例化对象的时候执行
建议：空参有参都手动给出
3.局部变量优先执行
比如在一个方法中有this.name和name,先执行局部变量的name
栈 :

    存储局部变量 在方法中或者是在方法的声明上()存储的变量

    程序的运行都必须要进栈的

堆:

    只要是能被new出来的都是存储在堆内存中

    地址值是以十六进制的形式打印出来的

    成员变量都是有默认初始化值

方法区:

    存储.class相关信息,包含方法的信息
------------------------------------Day8----------------------------
1.String类
1）因为是在lang包下，应用的较为频繁，所以不需要导包，而且就算导了也不会报错
  但对于java.util的包以及其它非lang包则必须导包
2）四种创建字符串对象的方式
   String s1= new String();
   new String(new char[]);
   new String(new byte[]);
   String str="";

一般采用最后一个直接创建的方式
3）通过new String实例化对象的方式，每次new,就占一块独立内存
   String s="";时，指向常量池的同一块内存，则共享一块内存。
2.使用==作比较
基本类型：比较的是数据值是否相同
引用类型：比较的是地址是否相同
而若想判断字符串内容是否相同，则用equals方法（s1.equals(s2)）
3.String str="123456789";
  //长度
        System.out.println(str.length());
        //内容是否相等
        System.out.println(str.equals("123456789"));
        String str1="abc";
        System.out.println(str1.equals("aBc"));
        System.out.println(str1.equalsIgnoreCase("ABC"));
       //取字符
        System.out.println(str1.charAt(0));
        //判断开始
        System.out.println(str.startsWith("123"));
        //判断结束
        System.out.println(str.endsWith("789"));
        //子字符串
        System.out.println(str.substring(1,6));
        System.out.println(str.substring(2));
        //是否包含
        System.out.println(str.contains("456"));
        //字符出现的位置
        System.out.println(str.indexOf('6'));
        System.out.println(str.indexOf('y'));
        System.out.println(str.indexOf("12"));
运行结果如下：
9
true
false
true
a
true
true
23456
3456789
true
5
-1
0
4.StringBuilder
append()方法：添加数据，并返回数据本身
链式编程：sb.append().append().append();
------------------------------------Day9---------------------------
1.\t:转义字符
2.想要彻底结束，就写return;
-------------------------------Day 6.18  继承-----------（面试的点）----

继承的优点：1,提高代码的复用性  2.提高了代码的维护性

1.子类中所有构造方法默认都会访问父类中无参的构造方法。
2.如果在子类中显示调用父类中的方法，则super（）一定要是方法当中除注释以外的第一句，否则会报错；
3.this（）调用构造方法，则必须是第一句，同2的super()方法。
  但this.id调用成员变量/属性时，则不必是第一句。
4.调用本类方法，show（）或者this.show()均可，而如果子类中的方法名与父类中的方法名重名，则为了区分调用的是哪个方法采用super（），如果只有show,就是采用就近原则。
5.被static修饰的类中某个属性，比如public static String company,所有对象将共用这个属性的值。调用方法为：类名.属性名；
6.静态成员方法只能访问静态成员（变量、方法），因为main方法为静态成员方法，所以要用static修饰
而非静态成员方法则可以访问任何其他方法。
-----------------------------------Day 6.19 多态--------------------------
1.父类引用指向子类对象
  Animal a=new Cat();
成员变量访问特点：编译看左面，运行看左面
成员方法访问特点：编译看左面，执行看右面（因为子类进行了重写，所以调用了子类，但如果没有重写子类，则是运行父类）
2.多态中的转型：
向上转型：父类引用指向子类对象（比如Animal a=new Cat();）
向下转型：子类型 对象名=（子类型）父类引用；（比如Cat c=(Cat)a;）

2.父类的成员变量和成员方法（即属性和行为）可以继承，但是构造方法不可以继承

3.抽象类的④大特点：
1）抽象类和抽象方法必须用abstract关键字修饰
2)抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
3）抽象类不能实例化对象（若想实例化，则只能是参照多态的方式，通过子类对象实例化即类似 Animal a=new Cat();）
4）抽象类的子类
   要么重写抽象类中的所有抽象方法
   要么是抽象类

3.1抽象类的成员特点：
1）成员变量：既可以是变量，也可以是常量
2）构造方法：空参构造，有参构造
3）成员方法：抽象方法，普通方法

4.接口:特殊类(java中的接口更多的体现在对行为的抽象)
类中所有方法都是抽象方法，与抽象类不同（允许有非抽象方法，即普通方法）

4.1 接口的特点：
1）接口用关键字interface修饰
2）类实现接口用implements表示
3）接口不可实例化对象，比如不可 jummping j=new jummping();只能是参照多态的方式，通过实现类对象实例化，这叫接口多态，比如jummping j=new Cat();
4）接口的子类
  要么重写接口中的所有抽象方法
  要么子类也是抽象类

4.2接口的成员特点：
1）成员变量：只能是常量，默认修饰符是public static final
2）构造方法：没有，因为接口主要是扩展功能的，而没有具体存在
3）成员方法：只能是抽象方法，而且所有的都是抽象方法，默认修饰符：public abstract

4.3
1> 类与类的关系：继承关系，只能单继承，但是可以多层继承
2> 类与接口的关系：实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时时实现多个接口
3> 接口与接口的关系：继承关系，可以单继承，也可以多继承。

来黑马程序员之后的部分纠错点：
1.关于常量的打印输出，下列哪个选项是正确的？（ A）
A：
System.out.println("");
B：
System.out.println('');
C：
System.out.println(null);
D：
System.out.println('ab');
答案解析：
A选项：该选项正确，空字符串常量可以通过打印语句输出。
B选项：该选项错误，字符常量，在单引号之间有且仅有一个字符。
C选项：该选项错误，空常量，不能使用打印语句输出。
D选项：该选项错误，字符常量，在单引号之间有且仅有一个字符，且不能为空。
2.下列代码的运行结果是（B ）
public static void main(String[] args){
    int x = 3;
    float y = x;
    System.out.println(y);     //错选为C
}
A.3    B.3.0   C.3.0F   D.3F
float是浮点数类型，需要显示出浮点数类型的结果，控制台当中不会出现F作为后缀
A选项：该选项错误，3的数据值是错误的，结果是float类型，需要显示浮点数结果，应该是3.0
B选项：该选项正确，3.0的数据值是正确的，结果是float类型，需要在末尾加上.0 表示浮点数
C选项：该选项错误，3.0F 控制台不能显示出后缀F，后缀F是为了区分单精度float和双精度double的书面写法
D选项：该选项错误，输出结果不会显示字母F，因为字母F只在定义Float类型变量使用，如果float类型变量初始值是整数，打印结果时后面加.0
3.一旦JDK的环境变量配置完成，就可以在任意目录下执行jdk给我们提供的相关命令。
4.public class Test4{
public static void main(String[] args){
         int a=10;
   System.out.println(a);
   a=a+10;
   
  System.out.println(a);
   short i=10;
    i=(short)(i+10);
   System.out.println(i);
        }
}
5.字符串常量：                用双引号括起来的内容。"HelloWorld","黑马程序员"
整数常量：                不带小数的数字。666, -88
小数常量：                带小数的数字。13.14, -5.21
字符常量：                用单引号括起来的内容。'A','0','我'
布尔常量：                布尔值，表示真假。只有两个值：true,false
空常量：                        一个特殊的值，空值，null（null值可以直接在输出语句打印吗？）
6.
在主方法中通过键盘录入三个整数。定义一个方法，方法接收三个整数变量，在方法中从大到小依次打印三个变量。执行效果如下：
请输入第一个整数：10
请输入第二个整数：30
请输入第三个整数：20
从大到小的顺序是： 30 20 10
1）方法一：
import java.util.Scanner;

public class demo1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个整数：");
        int number1 = sc.nextInt();
        System.out.println("请输入第二个整数：");
        int number2 = sc.nextInt();
        System.out.println("请输入第三个整数：");
        int number3 = sc.nextInt();
        get(number1,number2,number3);
    }


        public static void get(int number1,int number2,int number3 ){
             int temp=number1>number2?number1:number2;
             int max=temp>number3?temp:number3;
             int temp1=number1<number2?number1:number2;
             int min=temp1<number3?temp1:number3;

             int mid=number1+number2+number3-max-min;
            System.out.println("从大到小的顺序为："+max+","+mid+","+min);
        }
    }
2）方法二：
  public static void get(int number1,int number2,int number3 ){
             int temp=number1>number2?number1:number2;
             int max=temp>number3?temp:number3;
             int temp1=number1<number2?number1:number2;
             int min=temp1<number3?temp1:number3;

             int mid=number1+number2+number3-max-min;
            System.out.println("从大到小的顺序为："+max+","+mid+","+min);
        }
    }
6. 
A选项：该选项正确，使用面向对象的编程思想完成一个功能，需要找到一个能够完成该功能的对象，使用这个对象完成该功能，那么这个对象完成这个功能时需要一个步骤一个步骤的去完成，所以说面向对象是一种基于面向过程的编程思想。
B选项：该选项正确，使用面向对象编程思想完成一个功能，只要找到能完成该功能的对象，使用这个对象完成该功能即可，不需要关心过程中的每一个步骤。
C选项：该选项错误，王经理在完成修车这个功能时，每一个步骤都是自己亲力亲为，所以体现的是面向过程的编程思想。

D选项：该选项正确，小明在完成修电脑这个功能时，并没有亲力亲为，而是找会修电脑的师傅帮他完成，所以体现了面向对象的编程思想。
7.

面向对象思想,关注的是对象,让对象完成一个功能,我们关注的是结果而不是功能的每一个步骤!
生活中有很多面向对象思想的例子：
举例:洗衣服
面向过程：把衣服脱下来-->找一个盆-->放点洗衣粉-->加点水-->浸泡10分钟-->揉一揉-->清洗衣服-->拧干-->晾起来 
面向对象：把衣服脱下来-->打开全自动洗衣机-->扔衣服-->按钮-->晾起来
面向过程：强调步骤。
面向对象：强调对象，这里的对象就是洗衣机。
8.代码如下，下列关于数组的反转描述正确的是（ ）
public static void main(String[] args) {
    int[] array = { 10, 20, 30, 40, 50 };
    for (int min = 0, max = array.length - 1; min < max; min++, max--) {
        int temp = array[min];
        array[min] = array[max];
        array[max] = temp;
    }
}
9.public int add(int a, int b)
{
int c = a + b;
return c;
System.out.println(c);
该选项考察方法中return语句执行流程的问题，一旦执行到return语句，后面的内容将不会执行，如果return语句后面具有必定会执行的其他语句，程序会编译失败。





学习笔记：
-----------------Day4-------------------------------------
1.项目--》模块module--》package包--》class类
2.psvm回车--快速生成main方法
   sout回车-- 快速生成输出语句
  ctrl+alt+空格-----内容辅助代码补全
   Ctrl+/ 单行注释
   ctrl+shift+/  多行注释
3.数组的定义格式：
（1）数据类型【】数组名    int【】arr；（最好用该种方式）double[ ] arr;
（2）数据类型 数组名【】   int arr【】;

4.不同数据类型系统给的默认值不同：
    byte short int long------》0
    float double         -------》0.0
    boolean               ------->false
    char---------------->' '
    String ------------>null
5.数组的静态初始化;
   格式1：int[ ] arr=new int[ ]{1,2,3};
   格式2：int [ ]arr={1,2,3};(两者均可，2较为常用)
--------------------Day5------------------------------
!!!!!!!!!!!------面试之重：方法重载
1.方法使用 的注意事项：必须先定义再调用。
2.形参：定义方法时的参数
   实参：调用方法时的参数
3.void表示无返回值，可以省略return，也可以单独书写return，后面不加数据。
--------------------Day7-------------------------------
1.this关键字
this修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）
方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
方法的形参如果没有与其同名，不带this修饰的变量指的是成员变量。
2.构造方法
  格式：修饰符 类名（参数）{
}
修饰符一般是public（无返回值类型，即无void）
构造方法在创建对象的时候调用执行 eg:Student s=new Student();
1）构造方法与类同名，支持重载
2）可以使用有参构造方法，对成员变量进行赋值，达到初始化数据的效果
3）如果没有定义构造方法，系统会给出一个默认的无参数构造方法，如果定义了构造方法，系统将不再提供默认的构造方法。  
4）只能在通过new实例化对象的时候执行
建议：空参有参都手动给出
3.局部变量优先执行
比如在一个方法中有this.name和name,先执行局部变量的name
栈 :

    存储局部变量 在方法中或者是在方法的声明上()存储的变量

    程序的运行都必须要进栈的

堆:

    只要是能被new出来的都是存储在堆内存中

    地址值是以十六进制的形式打印出来的

    成员变量都是有默认初始化值

方法区:

    存储.class相关信息,包含方法的信息
------------------------------------Day8----------------------------
1.String类
1）因为是在lang包下，应用的较为频繁，所以不需要导包，而且就算导了也不会报错
  但对于java.util的包以及其它非lang包则必须导包
2）四种创建字符串对象的方式
   String s1= new String();
   new String(new char[]);
   new String(new byte[]);
   String str="";

一般采用最后一个直接创建的方式
3）通过new String实例化对象的方式，每次new,就占一块独立内存
   String s="";时，指向常量池的同一块内存，则共享一块内存。
2.使用==作比较
基本类型：比较的是数据值是否相同
引用类型：比较的是地址是否相同
而若想判断字符串内容是否相同，则用equals方法（s1.equals(s2)）
3.String str="123456789";
  //长度
        System.out.println(str.length());
        //内容是否相等
        System.out.println(str.equals("123456789"));
        String str1="abc";
        System.out.println(str1.equals("aBc"));
        System.out.println(str1.equalsIgnoreCase("ABC"));
       //取字符
        System.out.println(str1.charAt(0));
        //判断开始
        System.out.println(str.startsWith("123"));
        //判断结束
        System.out.println(str.endsWith("789"));
        //子字符串
        System.out.println(str.substring(1,6));
        System.out.println(str.substring(2));
        //是否包含
        System.out.println(str.contains("456"));
        //字符出现的位置
        System.out.println(str.indexOf('6'));
        System.out.println(str.indexOf('y'));
        System.out.println(str.indexOf("12"));
运行结果如下：
9
true
false
true
a
true
true
23456
3456789
true
5
-1
0
4.StringBuilder
append()方法：添加数据，并返回数据本身
链式编程：sb.append().append().append();
------------------------------------Day9---------------------------
1.\t:转义字符
2.想要彻底结束，就写return;
-------------------------------Day 6.18  继承-----------（面试的点）----

继承的优点：1,提高代码的复用性  2.提高了代码的维护性

1.子类中所有构造方法默认都会访问父类中无参的构造方法。
2.如果在子类中显示调用父类中的方法，则super（）一定要是方法当中除注释以外的第一句，否则会报错；
3.this（）调用构造方法，则必须是第一句，同2的super()方法。
  但this.id调用成员变量/属性时，则不必是第一句。
4.调用本类方法，show（）或者this.show()均可，而如果子类中的方法名与父类中的方法名重名，则为了区分调用的是哪个方法采用super（），如果只有show,就是采用就近原则。
5.被static修饰的类中某个属性，比如public static String company,所有对象将共用这个属性的值。调用方法为：类名.属性名；
6.静态成员方法只能访问静态成员（变量、方法），因为main方法为静态成员方法，所以要用static修饰
而非静态成员方法则可以访问任何其他方法。
-----------------------------------Day 6.19 多态--------------------------
1.父类引用指向子类对象
  Animal a=new Cat();
成员变量访问特点：编译看左面，运行看左面
成员方法访问特点：编译看左面，执行看右面（因为子类进行了重写，所以调用了子类，但如果没有重写子类，则是运行父类）
2.多态中的转型：
向上转型：父类引用指向子类对象（比如Animal a=new Cat();）
向下转型：子类型 对象名=（子类型）父类引用；（比如Cat c=(Cat)a;）

2.父类的成员变量和成员方法（即属性和行为）可以继承，但是构造方法不可以继承

3.抽象类的④大特点：
1）抽象类和抽象方法必须用abstract关键字修饰
2)抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
3）抽象类不能实例化对象（若想实例化，则只能是参照多态的方式，通过子类对象实例化即类似 Animal a=new Cat();）
4）抽象类的子类
   要么重写抽象类中的所有抽象方法
   要么是抽象类

3.1抽象类的成员特点：
1）成员变量：既可以是变量，也可以是常量
2）构造方法：空参构造，有参构造
3）成员方法：抽象方法，普通方法

4.接口:特殊类(java中的接口更多的体现在对行为的抽象)
类中所有方法都是抽象方法，与抽象类不同（允许有非抽象方法，即普通方法）

4.1 接口的特点：
1）接口用关键字interface修饰
2）类实现接口用implements表示
3）接口不可实例化对象，比如不可 jummping j=new jummping();只能是参照多态的方式，通过实现类对象实例化，这叫接口多态，比如jummping j=new Cat();
4）接口的子类
  要么重写接口中的所有抽象方法
  要么子类也是抽象类

4.2接口的成员特点：
1）成员变量：只能是常量，默认修饰符是public static final
2）构造方法：没有，因为接口主要是扩展功能的，而没有具体存在
3）成员方法：只能是抽象方法，而且所有的都是抽象方法，默认修饰符：public abstract

4.3
1> 类与类的关系：继承关系，只能单继承，但是可以多层继承
2> 类与接口的关系：实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时时实现多个接口
3> 接口与接口的关系：继承关系，可以单继承，也可以多继承。