公告

今日内容

面向对象复习
- 类的创建------>必须掌握
- 对象的创建和使用------>必须掌握
- 匿名对象
继承
- 如何继承---继承的格式------>必须掌握
- 继承之后成员的访问特点------>必须掌握
- 方法重写以及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修饰的变量的特点
    只能赋值一次,不能重复赋值

posted on 2022-04-24 23:38 ofanimon 阅读(31) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部