01-复习回顾、继承、抽象类模板设计模式

day01【复习回顾、继承、抽象类模板设计模式】

今日内容

面向对象复习
- 类的创建------>必须掌握
- 对象的创建和使用------>必须掌握
- 匿名对象
继承
- 如何继承---继承的格式------>必须掌握
- 继承之后成员的访问特点------>必须掌握
- 方法重写以及this和super关键字------>理解并会使用
抽象类
- 定义抽象类------>必须掌握
- 抽象方法的定义和使用------>必须掌握
- 模板设计模式------>必须掌握
final 关键字
- 修饰类格式和特点
- 修饰方法格式和特点
- 修饰变量格式和特点------>必须掌握

第1章复习回顾

1.1 类和对象

定义一个类

格式:

修饰符 class 类名{
    // 成员变量
    // 成员方法
    // 构造方法
    // 代码块
    // 内部类
}

代码:

public class Person {
    // 成员变量
    private String name;
    private int age;

    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }

    // 成员方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void show(){
        System.out.println(name+","+age);
    }
}

创建并使用对象

格式:

创建对象: 类名 对象名 = new 类名(实参);
使用对象:
	访问成员变量: 对象名.成员变量名
	访问成员方法:
		无返回值的方法: 对象名.方法名(实参);
		有返回值的方法:
			直接调用: 对象名.方法名(实参);
			赋值调用: 数据类型 变量名 = 对象名.方法名(实参);
			输出调用: System.out.println(对象名.方法名(实参));

代码:

public class Test {
    public static void main(String[] args) {
        // 通过调用空参构造方法,创建Person类的对象
        Person p1 = new Person();

        // 通过调用满参构造方法,创建Person类的对象
        Person p2 = new Person("李四", 19);

        // 使用p1对象调用方法
        p1.setName("张三");
        p1.setAge(18);
        String name = p1.getName();
        System.out.println("姓名:" + name);
        System.out.println("年龄:" + p1.getAge());

        // 使用p2调用show方法
        p2.show();

    }
}

1.2 对象的内存图

画图依据

- 只要是new对象就会在堆区开辟一块独立的空间
- 只要调用方法,方法就会被加载进栈
- 只要方法执行完毕,方法就会被弹栈
- 方法执行的流程: 调用方法-->加载方法到栈区-->声明形参-->把实参传递给形参--->执行方法体-->结束方法,弹栈

内存图

1.3 匿名对象

概述

概述:匿名对象指的就是没有名字的对象.
特点: 只能使用一次

使用

import com.itheima.demo1_复习类的定义和对象的使用.Person;

public class Test {
    public static void main(String[] args) {
        /*
            - 概述:匿名对象指的就是没有名字的对象.
            - 特点: 只能使用一次
            - 使用: 如果某个类的对象只要使用一次,就可以使用匿名对象
         */
        // 创建Person对象---有名字
        Person p1 = new Person("张三",18);
        p1.show();

        System.out.println("-------------------");

        // 匿名对象
        new Person("李四",19).show();
        new Person("李四",19).show();
        // 这是2个不同的对象,只是所有属性值一样,因为只要new就会在堆区开辟一块空间创建该对象

        System.out.println("-------------------");
        // 调用method方法
        //以前的方式---使用有名字的对象
        //Person p2 = new Person("老王",20);
        //method(p2);

        //现在的方式----使用匿名对象
        method(new Person("老王",20));

    }

    public static void method(Person p){
        p.show();
    }

}

第2章继承

2.1 继承概述

为什么要有继承

生活中为什么要有继承
程序中为什么还要有继承

继承的概述

继承在java中指的是“一个类”可以“继承自”“另一个类”。 "被继承的类"叫做: 父类/超类/基类，"继承其他类的类"叫做:子类。继承后，“子类”中就“拥有”了“父类”中所有的成员(成员变量、成员方法)。 “子类就不需要再定义了”。

继承的好处

提高代码的复用性;
使类与类之间产生了关系,作为多态的前提条件

2.2 继承的格式

继承的格式

修饰符 class 子类名 extends 父类名{
    
}

继承的演示

父类

public class Person {
    // 成员变量
    private String name;
    private int age;

    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }

    // 成员方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void show(){
        System.out.println(name+","+age);
    }
}

子类
```
public class Student extends Person {}
```

测试类

public class Test {    public static void main(String[] args) {        // 创建Student对象        Student stu = new Student();        // 调用set\get方法以及show方法        stu.setName("张三");        stu.setAge(18);        System.out.println(stu.getName()+","+stu.getAge());        stu.show();    }}

2.3 扩展一个文件定义多个类

class Person{    String name;}class Student extends Person{}public class Test {    public static void main(String[] args) {        /*            1.一个文件中是可以定义多个类的            2.注意:                2.1 一个文件中定义多个类,只能有一个public修饰的类                2.2 使用public修饰的类的类名必须和文件名一致                2.3 工作中,都是一个类对应一个文件,不要一个文件中定义多个类,现在只是过渡一下         */        Student stu = new Student();        stu.name = "zs";        System.out.println(stu.name);// zs    }}

2.4 继承后成员访问规则

继承后构造方法的访问规则

子类无法继承父类的构造方法

class Person{    String name;    int age;    public Person(String name, int age) {        this.name = name;        this.age = age;    }    public Person() {    }}class Student extends Person{}public class Test {    public static void main(String[] args) {        // 子类是无法继承父类的构造方法        // 创建Student对象        //Student stu = new Student("张三",18);// 编译报错    }}

继承后私有成员的访问规则

子类可以继承父类的私有成员,但无法直接访问,可以间接访问
- 私有成员变量: 通过set\get方法间接访问
- 私有成员方法: 通过其他公共的方法间接访问
```
class Person{  private String name;  private void method(){      System.out.println("Person method方法...");  }  public String getName() {      return name;  }  public void setName(String name) {      this.name = name;  }  public void show(){      method();  }}
```
class Student extends Person{

public class Test {
public static void main(String[] args) {
/*
子类可以继承父类的私有成员,但无法直接访问,可以间接访问
- 私有成员变量: 通过set\get方法间接访问
- 私有成员方法: 通过其他公共的方法间接访问
*/
// 创建Student对象
Student stu = new Student();
//System.out.println(stu.name);// 编译报错
//stu.method();// 编译报错
```
    // 给从父类继承过来的name属性赋值和取值    stu.setName("张三");    System.out.println("name:"+stu.getName());    // 调用从父类继承过来的method方法---可以调用公共的show方法    stu.show();// Person method方法...}
```

继承后非私有成员的访问规则

子类可以继承父类的非私有成员,并且可以直接访问

访问规则: 优先在子类中查找,如果在子类中找到了就直接使用子类的,如果没有找到就去父类中查找...

class Person{    String name = "张三";    public void method(){        System.out.println("Person method...");    }}class Student extends Person{    String name = "李四";    public void method(){        System.out.println("Student method...");    }}public class Test {    public static void main(String[] args) {        /*            - 子类可以继承父类的非私有成员,并且可以直接访问            - 访问规则: 优先在子类中查找,如果在子类中找到了就直接使用子类的,如果没有找到就去父类中查找...         */        // 创建Student对象        Student stu = new Student();        // 访问从父类继承过来的非私有成员变量        System.out.println(stu.name);// 李四        // 访问从父类继承过来的非私有成员方法        stu.method();// Student method...    }}

2.5 方法重写

方法重写的概念

概念:子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同）,该方法就是重写的方法。

代码:

class Person{    public void method(){        System.out.println("Person method...");       }}class Student extends Person{    // 重写的方法    @Override    public void method(){        System.out.println("Student method...");    }        public void show(){        System.out.println("Student show...");    }}public class Test {    public static void main(String[] args) {        /*             概念:子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同）,该方法就是重写的方法。             特点:                 1.重写的方法可以使用@Override注解进行标识                2.子类继承父类的成员方法,如果子类有不同的实现,子类就可以重写从父类继承过来的方法                3.子类重写父类方法的访问权限,不能低于父类方法的访问权限                    访问权限修饰符的大小:  public  >  protected > 空的(默认)   >  private                        */    }}

重写的注意事项

方法重写是发生在父子类之间的关系。
子类方法重写父类方法，返回值类型、方法名和参数列表都要一模一样。
使用场景:父类的方法,子类有不同的实现,那么子类就需要重写父类的该方法
子类方法重写父类方法，必须要保证权限大于等于父类权限。
访问权限从大到小: public > protected > (默认) > private
使用@Override注解，检验是否重写成功，重写注解校验！
- 建议重写方法都加上这个注解，一方面可以提高代码的可读性，一方面可以防止重写出错！

2.6 this和super关键字

this关键字的三种用法

介绍:this可以访问本类的成员属性、成员方法、构造方法；

this访问本类成员变量: this.成员变量

class Fu {    int num = 10;        public void method(){        int num = 20;        System.out.println("访问局部变量num:"+num);// 20        System.out.println("访问成员变量num:"+this.num);// 10    }}public class Test {    public static void main(String[] args) {        // this修饰本类成员变量: this.成员变量名        // 作用: 用了区别同名的成员变量和局部变量        // 创建Fu类对象,调用method方法        Fu f = new Fu();        f.method();                //new Fu().method();            }}

this访问本类成员方法: this.成员方法名(实参);

class Fu {    public void method1(){        System.out.println("Fu method1...");    }    public void method2(){        System.out.println("Fu method2...");    }    public void show(){        // 调用Fu类中method1,method2方法        this.method1();        this.method2();    }}public class Test {    public static void main(String[] args) {        // this访问本类的成员方法: this.方法名(实参);        Fu f = new Fu();        f.show();    }}

this访问本类构造方法: 在本类的一个构造方法中，调用本类另一个构造方法

空参构造: this();
有参构造: this(实参);
注意:
- 1.调用本类的构造方法需要在本类的一个构造方法中
- 2.调用本类的构造方法的代码必须放在构造方法的第一行
- 3.调用本类的构造方法不能2个构造方法之间相互调用

class Fu{    String name;    int age;    public Fu() {        System.out.println("Fu 空参构造...");    }    public Fu(String name) {        this.name = name;    }    public Fu(int age) {        this.age = age;    }    public Fu(String name, int age) {        // 访问本类的空参构造        //this();        // 访问本类的有参构造        this(name);        //this.name = name;        this.age = age;    }}public class Test {    public static void main(String[] args) {        /*            this访问本类构造方法:  **在本类的一个构造方法中，调用本类另一个构造方法**             - 空参构造:  `this();`             - 有参构造:  `this(实参);`            - 注意:              - 1.调用本类的构造方法需要在本类的一个构造方法中              - 2.调用本类的构造方法的代码必须放在构造方法的第一行              - 3.调用本类的构造方法不能2个构造方法之间相互调用         */        Fu f = new Fu("张三", 18);        System.out.println(f.name+","+f.age);    }}

super关键字的三种用法

介绍:super可以访问父类的成员属性、成员方法、构造方法；

super访问父类的成员变量: super.父类成员变量名

class Fu {    int num = 10;}class Zi extends Fu {    int num = 20;    public void show() {        int num = 30;        System.out.println("笨类中局部变量num的值:" + num);        System.out.println("本类中成员变量num的值:" + this.num);        System.out.println("父类中成员变量num的值:" + super.num);    }}public class Test {    public static void main(String[] args) {        // super访问父类的成员变量:  super.父类成员变量名        // 创建Zi类对象        Zi zi = new Zi();        zi.show();    }}

super访问父类的成员方法: super.成员方法名(实参);

class Fu {    public void method(){        System.out.println("Person HelloWorld...");    }}class Zi extends Fu {    @Override    public void method() {        // 访问父类的method方法        super.method();        System.out.println("Student HelloWorld...");    }    public void show(){        // 访问本类的method方法        this.method();        // 访问父类的method方法        super.method();    }}public class Test {    public static void main(String[] args) {        // super访问父类的成员方法:  super.成员方法名(实参);        // 创建Zi类对象        Zi zi = new Zi();        zi.method();        System.out.println("------");        zi.show();    }}

super访问父类的构造方法: super(实参)

class Fu{    private String name;    private int age;    public Fu() {        System.out.println("Fu  空参构造...");    }    public Fu(String name, int age) {        this.name = name;        this.age = age;        System.out.println("Fu  有参构造...");    }}class Zi extends Fu{    public Zi() {        super();    }    public Zi(String name,int age){        // 调用父类的有参构造方法        super(name,age);    }}public class Test {    public static void main(String[] args) {        /*            super访问父类构造方法:  **在子类的一个构造方法中，调用父类的构造方法**            - 空参构造:  `super();`            - 有参构造:  `super(实参);`            - 注意:              - 1.调用父类的构造方法需要在子类的一个构造方法中              - 2.调用父类的构造方法的代码必须放在子类构造方法的第一行         */        // 通过空参构造方法创建Zi类对象        //Zi zi1 = new Zi();        // 通过有参构造方法创建Zi类对象        //Zi zi2 = new Zi("张三",18);    }}

2.7 super的注意事项

super的注意事项一

super访问成员变量和成员方法: 优先去父类中找,如果有就直接使用,如果没有就去爷爷类中找,如果有,就用,依次类推...

class Ye /*extends Object*/{  // Object类是根类    int num = 10;    public void method(){        System.out.println("Ye method...");    }}class Fu extends Ye{    /*int num = 20;    public void method(){        System.out.println("Fu method...");    }*/}class Zi extends Fu{    public void show(){        System.out.println(super.num);        super.method();    }}public class Test1 {    public static void main(String[] args) {        /*            #### super的注意事项一            - super访问成员变量和成员方法: 优先去父类中找,如果有就直接使用,如果没有就去爷爷类中找,如果有,就用,依次类推...         */        // 创建Zi类对象        Zi zi = new Zi();        // 使用zi类对象访问num成员方法        System.out.println(zi.num);        // 使用zi类对象访问method成员方法        zi.method();        System.out.println("---------------");        // 使用zi类对象访问show成员方法        zi.show();    }}

super的注意事项二

子类的构造方法默认会调用父类的空参构造方法,如果父类中没有空参构造方法,只定义了有参构造方法,会编译报错

class Fu{    public Fu() {        System.out.println("Fu 空参构造...");    }    public Fu(String name,int age) {        System.out.println("Fu 有参构造...");    }}class Zi extends Fu{    public Zi() {        //super();// 不写,默认也有    }    public Zi(String name){        //super();// 不写,默认也有    }}public class Test {    public static void main(String[] args) {        /*            #### super的注意事项二                - 子类的构造方法默认会调用父类的空参构造方法                - 如果父类中没有空参构造方法,只定义了有参构造方法,子类中会编译报错         */        // 通过zi类空参构造方法创建对象        Zi zi1 = new Zi();        // 通过zi类有参构造方法创建对象        Zi zi2 = new Zi("itheima");    }}

2.8 继承体系对象的内存图

书写继承案例

class Fu{    int num = 10;    public void method(){        System.out.println("Fu method...");    }}class Zi extends Fu{    int num = 20;    @Override    public void method() {        System.out.println("Zi method...");    }    public void show(){        int num = 30;        System.out.println("局部变量num的值:"+num);        System.out.println("本类成员变量num的值:"+this.num);        System.out.println("父类成员变量num的值:"+super.num);        // 调用本类的成员方法        this.method();        // 调用父类的成员方法        super.method();    }}public class Test {    public static void main(String[] args) {        // 创建Zi类对象        Zi zi = new Zi();        // 调用show方法        zi.show();    }}

根据案例绘制内存图

2.9 继承的特点

Java只支持单继承，不支持多继承。

public class A{}public class B{}public class C extends A extends B{} // 都是错误的public class C extends A , B{} // 都是错误的

一个类只能有一个父类,但可以有多个子类。

public class A{}public class B extends A{}public class C extends A{}

可以多层继承。

public class A{}public class B extends A{}public class C extends B{}

补充: Java中顶层父类是Object类。所有的类默认继承Object，作为父类。

class A {} 默认继承Object类直接继承Object

class B extends A{} B的父类就是A,但是A的父类是Object类间接继承Object类

第3章抽象类

3.1 抽象类的概述和定义

抽象类的概述

概述: 使用abstract修饰的类就是抽象类
特点:
- 抽象类不能创建对象
- 抽象类中可以写抽象方法

抽象类的定义

格式:

修饰符 abstract class 类名{    // 成员变量    // 成员方法    // 构造方法    // 代码块    // 内部类    // 抽象方法}

案例

public abstract class Animal {    // 成员变量    private String name;    // 构造方法    public Animal(String name) {        this.name = name;    }    public Animal() {    }    // 成员方法    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public void show() {        System.out.println("name:" + name);    }    // 抽象方法    // 代码块    // 内部类}

3.2 抽象方法的概述和定义

抽象方法的概述

概述: 没有方法体,并且使用abstract修饰的方法就是抽象方法

抽象方法的定义

格式: 修饰符 abstract 返回值类型方法名(形参列表);
案例:
```
public abstract void method();
```

3.3 抽象类的注意事项

抽象类不能被创建对象，只能用来做“父类”，被子类继承的，体现的是模板思想。

abstract class Animal{    }public class Test {    public static void main(String[] args) {        // 抽象类不能被创建对象，只能用来做“父类”，被子类继承的，体现的是模板思想 。        //Animal anl = new Animal();// 编译报错    }}

抽象类不能被创建对象，但可以有“构造方法”——目的:给子类初始化从父类继承过来的属性。

abstract class Animal{    private String name;    private int age;    public Animal() {    }    public Animal(String name, int age) {        this.name = name;        this.age = age;    }    public String getName() {        return name;    }    public int getAge() {        return age;    }}class Dog extends Animal{    public Dog(){    }    public Dog(String name,int age){        super(name,age);    }}public class Test {    public static void main(String[] args) {        // 抽象类不能被创建对象，但可以有“构造方法”——目的:给子类初始化从父类继承过来的属性。         // 说白了就是抽象父类中的构造方法就是供子类构造方法来调用的        // 需求: 创建Dog类对象,并初始化从Animal类中继承过来的成员变量        Dog dog = new Dog("旺财",2);        System.out.println(dog.getName());        System.out.println(dog.getAge());    }}

抽象类中可以没有抽象方法,但抽象方法必须定义在抽象类中

// 抽象类abstract class Animal{    // 抽象类中可以没有抽象方法}abstract class Person{    // 但抽象方法必须定义在抽象类中    public abstract void method();}public class Test {    public static void main(String[] args) {        // 抽象类中可以没有抽象方法,但抽象方法必须定义在抽象类中    }}

子类继承抽象类后,必须重写抽象类中所有的抽象方法,否则子类必须也是一个抽象类

abstract class Animal{    public abstract void eat();    public abstract void drink();}// 抽象类的子类是抽象类,可以不用重新抽象类中的抽象方法abstract class Cat extends Animal{}// 抽象类的子类是普通类,那就必须重写抽象类中所有的抽象方法class Dog extends Animal{    @Override    public void eat() {    }    @Override    public void drink() {    }}public class Test {    public static void main(String[] args) {        // 子类继承抽象类后,必须重写抽象类中所有的抽象方法,否则子类必须也是一个抽象类    }}

3.4 模板设计模式

设计模式: 设计模式就是解决一些问题时的固定思路，也就是代码设计思路经验的总结。
模板思想:
- 模板是通用的东西，抽象类体现的是模板思想。
- 抽象类中可以是具体实现的方法(通用模板),也可以有抽象方法(填充模板)。
- 模板中能决定的行为就定义成有方法体的方法，让需要使用模板的类（子类）直接继承调用即可。
- 模板中不能决定的行为定义成抽象方法，让需要使用模板的类（子类）负责重写抽象方法实现。

案例:

需求:按照下述要求，使用代码实现
定义新、老司机类，新、老司机类都有开车功能，开车的步骤一样，但驾驶时的姿势不同
新司机:开门,点火,双手紧握方向盘,刹车,熄火
老司机:开门,点火,右手握方向盘左手抽烟,刹车,熄火

代码:

// 抽象父类public abstract class Driver {    // 通用模板(有方法体的方法)    public void drive(){        System.out.println("开门");        System.out.println("点火");        // 姿势        ziShi();        System.out.println("刹车");        System.out.println("熄火");    }    // 填充模板(没有方法体的方法)    public abstract void ziShi();}public class NewDriver extends Driver {    @Override    public void ziShi() {        System.out.println("双手紧握方向盘");    }}public class OldDriver extends Driver {    @Override    public void ziShi() {        System.out.println("右手握方向盘左手抽烟");    }}package com.itheima.demo12_模板设计模式;public class Test {    public static void main(String[] args) {        // 创建新司机对象,调用开车的方法        new NewDriver().drive();        // 创建老司机对象,调用开车的方法        new OldDriver().drive();    }}

第4章 final关键字

4.1 final关键字的概述和使用

final关键字的概述

概述: final是一个关键字,表示最终,不可变的意思,可以用来修饰类,修饰方法,修饰变量
特点:
- 被final修饰的类不能被继承
- 被final修饰的方法不能被重写
- 被final修饰的变量不能重复赋值,只能赋值一次

final关键字的使用

修饰类

格式:
```
修饰符 final class  类名{    }
```

案例:

final class Fu{    }class Zi /*extends Fu*/{    // 编译报错,被final修饰的类不能被继承    }public class Test {    public static void main(String[] args) {            }}

修饰方法

格式: 修饰符 final 返回值类型方法名(形成列表){ 方法体 }
特点: 被final修饰的方法不能被重写

案例:

class Fu{        public final void method(){        System.out.println("Fu method...");    }}class Zi extends Fu{    // 编译报错,因为被final修饰的方法不能被重写    /*@Override    public void method(){        System.out.println("Zi method...");    }*/}public class Test {    public static void main(String[] args) {            }}

修饰变量

格式:
- 方式一: final 数据类型变量名 = 值;
- 方式二: final 数据类型变量名; 变量名 = 值;
特点:
- 被final修饰的变量不能重复赋值,只能赋值一次
- 被final修饰的变量其实也叫作常量,常量命名规范是所有字母大写

final修饰局部变量案例:

public class Test1_局部变量 {    public static void main(String[] args) {        // 定义一个NUM局部变量并赋值        final int NUM = 10;        // 重新给num赋值        // NUM = 20;// 编译报错,被final修饰的变量不能重复赋值,只能赋值一次        // 打印输出        System.out.println(NUM);// 10        System.out.println("-----------------");        final int A;        A = 20;        //A = 30;// 编译报错,被final修饰的变量不能重复赋值,只能赋值一次        System.out.println(A);// 20    }}

final修饰成员变量案例:

方式一:class Person{    // final 数据类型 变量名 = 值;    final int AGE = 10;}方式二:class Animal{    final int age;    public Animal(int age) {        this.age = age;    }    public Animal() {        age = 20;    }    // 只要保证age成员变量出现的时候有值}public class Test2_成员变量 {    public static void main(String[] args) {        /*            成员变量和局部变量的区别:                1.成员变量定义在类中方法外,局部变量定义在方法中或者方法声明之上(参数)                2.成员变量是在堆区,局部变量是在栈区                3.成员变量是随着对象的创建而存在,随着对象的销毁而销毁;                  局部变量是随着方法的调用而存在,随着方法的弹栈而销毁                4.成员变量有默认值,而局部变量没有默认值         */        Animal anl = new Animal(20);        //anl.age = 100;// 编译报错,因为被final修饰的变量不能重复赋值,只能赋值一次        System.out.println(anl.age);    }}

总结

必须练习:	1.定义类,创建对象,使用对象----->必须掌握    2.继承的格式,继承后成员访问规则--->必须掌握    3.this和super关键字的三种用法--->必须掌握    4.方法重写--->必须掌握    5.抽象类的定义以及使用--->必须掌握    6.抽象方法的定义以及使用--->必须掌握    7.fianl关键字修饰类,方法,变量--->必须掌握     - 能够写出类的继承格式    修饰符 class 子类名 extends 父类名{}- 能够说出继承的特点    1.子类继承父类后,就可以拥有父类所有的成员变量和成员方法    2.子类继承父类后,可以直接访问从父类继承过来的非私有成员    3.只能单继承,不能多继承,但可以多层继承    4.不要为了继承而继承,必须满足is a的关系才去继承    - 能够说出子类调用父类的成员特点    子类继承父类后,可以直接访问从父类继承过来的非私有成员    子类继承父类后,不可以直接访问从父类继承过来的私有成员,需要间接访问    - 够说出方法重写的概念    概念: 子类中出现和父类一模一样的方法(返回值类型,方法名,参数列表),该方法就是重写的方法    特点:		1.子类重写的方法的权限不能低于父类方法的权限           public > protected > 默认 > private        2.重写的方法可以使用@Override注解进行标识,可以起到提高代码可读性以及校验重写是否正确的作用            - 能够说出this可以解决的问题   this可以访问本类的成员变量: this.成员变量名   this可以访问本类的成员方法: this.成员方法名(实参);   this可以访问本类的构造方法: this(实参);- 能够说出super可以解决的问题   super可以访问父类的成员变量: super.成员变量名   super可以访问父类的成员方法: super.成员方法名(实参);   super可以访问父类的构造方法: super(实参);- 描述抽象方法的概念    概念: 没有方法体,并且使用abstract修饰的方法- 写出抽象类的格式   概述:使用abstract修饰的类就是抽象类   格式:修饰符 abstract class 类名{}   特点: 		1.抽象类的子类可以是普通类,也可以是抽象类        2.抽象类的子类是普通类,必须重写抽象类中所有的抽象方法,否则抽象类的子类必须也是抽象类        3.有抽象方法的类一定是抽象类,但抽象类中不一定有抽象方法            - 写出抽象方法的格式   格式: 修饰符 abstract 返回值类型 方法名(实参);- 能够说出父类抽象方法的存在意义   强制要求子类重写    - 描述final修饰的类的特点    不能被继承    - 描述final修饰的方法的特点    不能被重写    - 描述final修饰的变量的特点    只能赋值一次,不能重复赋值

001_JavaSE