Java-进阶-day01-继承
Java进阶-day01-继承
- 继承(重点)
- 权限修饰符
- final & static
继承
一、 继承的概述和特点
- A.什么是继承?
- B.继承的格式?
- C.继承的好处和弊端?
总结:
* A:什么是继承
* 多个类中有相同的成员,把这些相同的成员抽取到一个类中,那么这个类就是父类(基类 超类)
由这个父类生成的类叫子类(派生类)
* B:继承的格式和使用
* 格式:
public class Fu类{
}
public class 子类 extends Fu类{
}
使用:
以后我们使用的都是子类
继承的特点:
* 子类自动拥有了父类非私有的成员
* 子类还可以有自己特有的成员
* C:继承的好处和弊端
* 好处:
提高了代码的复用性
提高了代码的维护性
* 弊端:
类与类之间的关系,太紧密 耦合性太强了
高内聚 低耦合--> 解耦
编译时期: 看不到类与类之间的关系
运行时期: 是有关系的 --> 反射 和 配置文件
- 3.继承中成员变量访问的特点?
总结:
1. 首先看子类局部中有没有这个变量,如果有直接使用
2. 如果没有这个变量,去子类成员的位置找这个变量,如果有直接使用
3. 如果没有这个变量,去找父类看有没有这个变量,如果有直接使用,没有则报错
super 和 this 的三种用法:
* this 三种用法:
* 访问子类成员变量: this.成员变量
* 访问子类成员方法: this.成员方法(参数列表)
* 访问子类构造方法: this(参数列表);
* super 三种用法:
* 访问父类成员变量: super.成员变量
* 访问父类成员方法: super.成员方法(参数列表)
* 访问父类构造方法: super(参数列表);
- 4 继承中的构造方法的访问特点
总结：
问题: 创建子类对象的时候,为什么会先执行父类的构造方法?
子类需要用到父类中的成员,用于给父类先进行初始化
问题: 如何手动调用父类的其他构造方法?
必须是在子类中构造方法的第一行写super(参数列表)\
在创建子类对象时,始终都是要走父类的构造,默认是访问父类的无惨构造方法
在子类构造方法中的第一行默认有super();
如果不想默认访问父类的无参构造我们需要手动的在子类构造方法中的第一行写super(参数列表)
一旦我们手动给出访问父类其他有参构造,系统就不会在默认调用父类无参构造
- 4.继承中成员方法的访问特点
总结:
问题:如果子类没有这个方法,使用的是父类的还是子类的?
使用的是父类的
问题:继承中如果出现了重名的成员方法,调用的时候.执行的是父类的还是子类的?
子类的 重要的概念:方法的重写
- 5.super内存图（理解）
总结:对象在堆内存中，会单独存在一块super区域，用来存放父类的数据
二、 方法重写应用场景和注意事项
- 1.方法重写的应用场景:
- 2.方法重写的注意事项:
总结:
面试题：Overload和Override之间的区别
* A:Overload(重载)：在同一个类中,方法名相同,参数类表不同,与返回值无关
参数列表:
* 个数不同
* 与之对应的数据类型是否相同
* B:Override(覆盖重写)：
在子父类/接口实现关系中,方法名相同 参数列表也相同 返回值也一样 权限必须是大于等于父类的权限
a:方法重写的应用场景
当父类中的功能满足不了子类需求的是我们可以重写父类中的方法
父类的功能满足子类需求,就不需要重写了,直接使用
好处是什么?
子类既有了自己特有的功能,又保有了父类原有的功能
b:方法重写的注意事项
* 子类不能重写父类私有的方法
* 子类的权限必须是大于等于父类的权限
- 3.Java中继承的注意事项
总结:
* java中只支持单继承,不能多继承 (一个儿子只能有一个亲爹)
* java中支持多层继承(一个儿子只能有一个亲爹,还能有一个亲爷爷)
class A{}
class B extends A{}
class C extends B{}
继承案例:
案例一: 老师和学生（应用）
需求：定义老师类和学生类，然后写代码测试；最后找到老师类和学生类当中的共性内容，抽取出一个父类，用继承的方式改写代码，并进行测试
步骤：
①定义老师类(姓名，年龄，教书())
②定义学生类(姓名，年龄，学习())
③定义测试类，写代码测试
④共性抽取父类，定义人类(姓名，年龄)
⑤定义老师类，继承人类，并给出自己特有方法：教书()
⑥定义学生类，继承人类，并给出自己特有方法：学习()
⑦定义测试类，写代码测试
- Person类（Student和Teacher类的父类）
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
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;
}
}
- Student类（Person类的子类）
class Student extends Person {
public Student() {
}
public Student(String name, int age) {
super(name, age);
}
void study() {
System.out.println("学习");
}
}
- Teacher类（Person类的子类）
public class Teacher extends Person {
public Teacher() {
}
public Teacher(String name, int age) {
super(name, age);
}
void teach() {
System.out.println("教学");
}
}
- Demo类（测试类）
public class Demo {
public static void main(String[] args) {
Teacher t1 = new Teacher();
t1.setName("张三");
t1.setAge(30);
System.out.println(t1.getName() + ", " + t1.getAge());
t1.teach();
Teacher t2 = new Teacher("李四",33);
System.out.println(t2.getName() + ", " + t2.getAge());
t2.teach();
Student stu = new Student();
stu.setName("王五");
stu.setAge(18);
System.out.println(stu.getName() + ", " + stu.getAge());
stu.study();
}
}
案例二:猫和狗
需求：请采用继承的思想实现猫和狗的案例，并在测试类中进行测试
分析：
①猫：
成员变量：姓名，年龄
构造方法：无参，带参
成员方法：get/set方法，抓老鼠()
②狗：
成员变量：姓名，年龄
构造方法：无参，带参
成员方法：get/set方法，看门()
③共性：
成员变量：姓名，年龄；构造方法：无参，带参；成员方法：get/set方法
步骤：
1、定义动物类(Animal)
【成员变量：姓名，年龄】【 构造方法：无参，带参】【成员方法：get/set方法】
2、定义猫类(Cat)，继承动物类
【构造方法：无参，带参】【成员方法：抓老鼠() 】
3、定义狗类(Dog)，继承动物类
【构造方法：无参，带参】【成员方法：看门() 】
4、定义测试类(AnimalDemo)，写代码测试
- Animals类（Cat类和Dog类的父类）
public class Animals {
private String breed;
private String color;
public Animals() {
}
public Animals(String breed, String color) {
this.breed = breed;
this.color = color;
}
public String getBreed() {
return breed;
}
public void setBreed(String breed) {
this.breed = breed;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
void eat() {
System.out.println("eating");
}
void bark() {
System.out.println("barking");
}
}
- Cat类（Animals类的子类）
public class Cat extends Animals {
public Cat() {
}
public Cat(String breed, String color) {
super(breed, color);
}
@Override
void eat() {
System.out.println("eating fish");
}
@Override
void bark() {
System.out.println("meow");
}
}
- Dog类（Animals类的子类）
public class Dog extends Animals {
public Dog() {
}
public Dog(String breed, String color) {
super(breed, color);
}
@Override
void eat() {
System.out.println("eating bone");
}
@Override
void bark() {
System.out.println("woof");
}
}
- AnimalsDemo类（测试类）
public class AnimalsDemo {
public static void main(String[] args) {
Cat cat = new Cat("狸花猫", "花色");
Dog dog = new Dog("博美犬", "白色");
cat.eat();
cat.bark();
System.out.println("--------");
dog.eat();
dog.bark();
Animals cat1 = new Cat("美国短毛猫", "黑白色");
System.out.println("-------");
cat1.bark();
cat1.eat();
}
}
权限修饰符
- package
1、包的概念
包就是文件夹，用来管理类文件的
2、包的定义格式
package 包名; (多级包用.分开)
例如：package com.heima.demo;
3、带包编译&带包运行
带包编译：javac –d . 类名.java
例如：javac -d . com.heima.demo.HelloWorld.java
带包运行：java 包名+类名
例如：java com.heima.demo.HelloWorld
- import
导包的意义
使用不同包下的类时，使用的时候要写类的全路径，写起来太麻烦了。
为了简化带包的操作，Java就提供了导包的功能
导包的格式
格式：import 包名;
范例：import java.util.Scanner;
import java.util.* : 表示的是将util包下的所有的类,导入到当前这个类中
- 权限修饰符
private: 只能是在本类中访问
默认: 只能是在本包使用
protected: 只给子类使用(同包下/不同包下/本类),只能是在子类的内部使用,出了这个子类就不能使用了
public: 在任意个包下都能使用
- final关键字
- 什么是final关键字
- fianl关键字的特点
总结：
1.什么是final
表示最终的意思
2.特点
final修饰的类: 最终的一个类,是没有子类的(太监类),还是可以有父类的
final修饰的成员方法: 不能被重写
final修饰的成员变量: 叫常量
常量的分类:
* 字面值常量: "HelloWorld" 1 true
* 自定义常量:
* 静态常量:
public static final 数据类型 常量名 = 值;
* 常量:
public final 数据类型 常量名 = 值;
final修饰引用数据类型：修饰的是对象的地址值,但是对象中的内容是可以改变的
final int[] arr = new int[10];
final修饰基本数据类型：修饰的是具体的数值是不能改变的
final int NUMBER = 20;
- static关键字
- static可以修饰什么?
- 被其修饰的(成员)有什么特点?
总结:
* static 可以修饰什么
可以修饰成员变量和成员方法(工具类)
* static 修饰的特点
属于共享数据,就不在属于某一个对象了,属于类的
* 静态修饰的成员变量调用方式有几种方式?
有两种方式:
* 对象名.静态成员
Student stu = new Student();
stu.classRoom = "305";
* 类名.静态成员(推荐方式)
Student.classRoom = "305";
- static访问特点
总结:
静态只能访问静态的
本质:
static 优先于非静态加载内存的
int NUMBER = 20;
- static关键字
- static可以修饰什么?
- 被其修饰的(成员)有什么特点?
总结:
* static 可以修饰什么
可以修饰成员变量和成员方法(工具类)
* static 修饰的特点
属于共享数据,就不在属于某一个对象了,属于类的
* 静态修饰的成员变量调用方式有几种方式?
有两种方式:
* 对象名.静态成员
Student stu = new Student();
stu.classRoom = "305";
* 类名.静态成员(推荐方式)
Student.classRoom = "305";
- static访问特点
总结:
静态只能访问静态的
本质:
static 优先于非静态加载内存的