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