继承修饰符
1.继承
1.1 继承的概念
继承是面向对象三大特征之一,可以使子类具有父类中非私有的属性和方法(意思就是不是用 private所修饰的都可以获得),还可以在子类中重新定义,以及追加属性和方法。
格式：
public class 子类名 extends 父类名{}
例如：
public class Cat extends Animal {}
例：public class Fu {
public void show() {
System.out.println(“show方法被调用”);
}
}
public class Zi extends Fu {
public void method() {
System.out.println(“method方法被调用”);
}
}
public class Demo {
public static void main(String[] args) {
//创建对象，调用方法
Fu f = new Fu();
f.show();
Zi z = new Zi();
z.method();
z.show();
}
}
优点:
1.可以将子类中重复的内容提取出来放到父类中, 达到了简化代码目的---->代码复用性(多个类相同的成员可以放到同一个类中)
2.可以提高代码维护性(如果方法的代码需要修改，修改一处即可)
弊端:
削弱子类的独立性
名词:
父类: 被继承的类, 超类, 基类
子类: 继承的类,派生类
继承的应用场景：
- 使用继承，需要考虑类与类之间是否存在is…a的关系，不能盲目使用继承
- is…a的关系：谁是谁的一种，例如：老师和学生是人的一种，那人就是父类，学生和老师就是子类
2.继承中的成员访问特点
2.1继承中变量的访问特点（掌握）
记住继承中访问的特点, 遵循"就近原则";
即：
- 子类局部范围找
- 子类成员范围找
- 父类成员范围找
- 如果都没有就报错(不考虑父亲的父亲…)
如果说非要访问子类成员区域的东西, 请你加this,如果非要访问父类相关的东西,请你加super
this:访问本类的成员(成员变量,成员方法),构造函数
super:访问父类的成员(成员变量,成员方法),构造函数
this虽然是找本类的成员,但是如果本类没有依然可以找父类的东西
2.2 super（掌握）
this&super关键字：
-
this：代表本类对象的引用
-
super：代表父类存储空间的标识(可以理解为父类对象引用)
-
this和super的使用分别
- 成员变量：
- this.成员变量 - 访问本类成员变量
- super.成员变量 - 访问父类成员变量
- 成员方法：
- this.成员方法 - 访问本类成员方法
- super.成员方法 - 访问父类成员方法
- 成员变量：
-
构造方法：
- this(…) - 访问本类构造方法
- super(…) - 访问父类构造方法
2.3 继承中构造方法的访问特点（理解）
注意：子类中所有的构造方法默认都会访问父类中无参的构造方法
子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化，原因在于，每一个子类构造方法的第一条语句默认都是：super()问题：如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢？
1. 通过使用super关键字去显示的调用父类的带参构造方法 2. 在父类中自己提供一个无参构造方法推荐方案：
自己给出无参构造方法
2.4 继承中成员方法的访问特点（掌握）
通过子类对象访问一个方法
- 子类成员范围找
- 父类成员范围找
- 如果都没有就报错(不考虑父亲的父亲…)
子父类中构造函数的特点:(重点!!!)**
构造函数作用: 给成员变量和成员方法进行初始化的, 也就是没有走构造函数所有的普通的成员变量和成员方法是不可以使用的,因为没有初始化
子类的构造第一行如果没有调用任何构造, 系统非常爱我们, 默认帮我们调用父类的无参构造, 为什么??? 因为父类构造没有走的话, 父类相关的不能被使用!!!
如果父类没有无参, 子类必须手动去调用父类的有参构造!!!**
2.5 方法重写（掌握）
- 1、方法重写概念
- 子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）
- 2、方法重写的应用场景
- 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容
- 3、Override注解
- 用来检测当前的方法，是否是重写的方法，起到【校验】的作用
2.6 方法重写的注意事项（掌握）
- 方法重写的注意事项
- 私有方法不能被重写(父类私有成员子类是不能继承的)
- 子类方法访问权限不能更低(public > 默认 > 私有)
示例代码：public class Fu {
private void show() {
System.out.println(“Fu中show()方法被调用”);
}
void method() {
System.out.println("Fu中method()方法被调用");
}
}
public class Zi extends Fu {
/* 编译【出错】，子类不能重写父类私有的方法*/
@Override
private void show() {
System.out.println("Zi中show()方法被调用");
}
/* 编译【出错】，子类重写父类方法的时候，访问权限需要大于等于父类 */
@Override
private void method() {
System.out.println("Zi中method()方法被调用");
}
/* 编译【通过】，子类重写父类方法的时候，访问权限需要大于等于父类 */
@Override
public void method() {
System.out.println("Zi中method()方法被调用");
}
}
2.7. Java中继承的注意事项（掌握）
- Java中继承的注意事项
- Java中类只支持单继承，不支持多继承
- 错误范例：class A extends B, C { }
- Java中类支持多层继承
- Java中类只支持单继承，不支持多继承
示例代码：public class Granddad {
public void drink() {
System.out.println("爷爷爱喝酒");
}
}
public class Father extends Granddad {
public void smoke() {
System.out.println("爸爸爱抽烟");
}
}
public class Mother {
public void dance() {
System.out.println("妈妈爱跳舞");
}
}
public class Son extends Father {
// 此时，Son类中就同时拥有drink方法以及smoke方法
}
3. 继承练习
3.1 老师和学生（应用）
-
需求：定义老师类和学生类，然后写代码测试；最后找到老师类和学生类当中的共性内容，抽取出一个父类，用继承的方式改写代码，并进行测试
-
步骤：
①定义老师类(姓名，年龄，教书())
②定义学生类(姓名，年龄，学习())
③定义测试类，写代码测试
④共性抽取父类，定义人类(姓名，年龄)
⑤定义老师类，继承人类，并给出自己特有方法：教书()
⑥定义学生类，继承人类，并给出自己特有方法：学习()
⑦定义测试类，写代码测试
-
示例代码：
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; } } class Teacher extends Person { public Teacher() {} public Teacher(String name,int age) { super(name,age); } public void teach() { System.out.println("用爱成就每一位学员"); } } class Student extends Person{ public Student() {} public Student(String name, int age) { super(name,age); } public void study(){ System.out.println("学生学习"); } } class PersonDemo { 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 s = new Student("张三"，23)； System.out.println(s.getName() + "," + s.getAge()); s.study(); } }
3.2 猫和狗（ 应用）
-
需求：请采用继承的思想实现猫和狗的案例，并在测试类中进行测试
-
分析：
①猫：
成员变量：姓名，年龄 构造方法：无参，带参 成员方法：get/set方法，抓老鼠()②狗：
成员变量：姓名，年龄 构造方法：无参，带参 成员方法：get/set方法，看门()③共性：
成员变量：姓名，年龄；构造方法：无参，带参；成员方法：get/set方法 -
步骤：
1、定义动物类(Animal)
【成员变量：姓名，年龄】【 构造方法：无参，带参】【成员方法：get/set方法】2、定义猫类(Cat)，继承动物类
【构造方法：无参，带参】【成员方法：抓老鼠() 】3、定义狗类(Dog)，继承动物类
【构造方法：无参，带参】【成员方法：看门() 】4、定义测试类(AnimalDemo)，写代码测试
-
示例代码：
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 void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } } class Cat extends Animal { public Cat() { } public Cat(String name, int age) { super(name, age); } public void catchMouse() { System.out.println("猫抓老鼠"); } } class Dog extends Animal { public Dog() { } public Dog(String name, int age) { super(name, age); } public void lookDoor() { System.out.println("狗看门"); } } /* 测试类 */ public class AnimalDemo { public static void main(String[] args) { //创建猫类对象并进行测试 Cat c1 = new Cat(); c1.setName("加菲猫"); c1.setAge(5); System.out.println(c1.getName() + "," + c1.getAge()); c1.catchMouse(); Cat c2 = new Cat("加菲猫", 5); System.out.println(c2.getName() + "," + c2.getAge()); c2.catchMouse(); } }
4.修饰符
4.1 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
- 带包编译：javac –d . 类名.java
4.2常用的关键字：
extends : 可以用来描述继承关系
super: 可以访问父类的内容
package: 声明这个类在哪个包下
import: 可以将其他包中的内容引入到本类中
注意: 1.要使用的类和本类在同一个文件夹
2.java.lang包下的内容, 都可以不用导包, 其他都需要导包
4.3 权限修饰符（理解）
本类 本包 不同包子类 不同包无关类
public Y Y Y Y
protected Y Y Y
什么都不写 Y Y
private Y
4.4 final修饰局部变量（理解）
-
fianl修饰基本数据类型变量
- final 修饰指的是基本类型的数据值不能发生改变
-
final修饰引用数据类型变量
-
final 修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的
-
举例：
public static void main(String[] args){ final Student s = new Student(23); s = new Student(24); // 错误 s.setAge(24); // 正确 }
-
作用: 能够修饰类, 方法, 变量
1.修饰类: ---->这个类是最终类, 不能有子类.
使用场景: 当你觉得你的写类所有东西的很完美, 不需要别人在修改了, 你就可以用final修改你写的类
2.修饰方法: —> 这个方法是最终方法, 不能被子类重写
使用场景: 当你某个方法写的已经很完美了,不希望别人修改你的这个方法, 就可以在这个方法上加上final
3.修饰变量: ----> 变成了常量, 自定义常量, 作用:经常让普通的常量更具备可读性!!!
修饰局部变量:
命名规则: 和普通变量没啥区别,符合小驼峰式
这个变量只能被赋值一次!!!
修饰成员变量:
命名规则: 建议每个单词都大写, 多个单词之间用"_"隔开
这个变量只能被赋值一次!!!!!!
初始化两种方式:
1.直接给赋值(推荐)
2.通过构造函数赋值(开发中不要使用!!!!!!!,因为太恶心,
因为必须保证每一个构造都要对final修改的成员变量就行赋值)
注意: 如果final修饰基本数据类型, 值不能被改变
如果final修饰引用数据类型, 地址值不能变,但是内容可以变量
final Student s = new Student();
s.age = 10; //这个正确
s = new Student();// 这个错误
4.5 static（应用）
- static的概念
- static关键字是静态的意思，可以修饰【成员方法】，【成员变量】
- static修饰的特点
- 被类的所有对象共享，这也是我们判断是否使用静态关键字的条件
- 可以通过类名调用当然，也可以通过对象名调用**【推荐使用类名调用】
作用: 能够修饰成员(成员变量,成员方法), 修饰代码块, 可以修饰成员内部类
特点: 都是随着类的字节码的加载而加载,在字节码加载好的时候已经完成初始化, 只会被加载一次!!!可以直接通过类名来使用
记住: 静态的东西不属于对象, 属于整个类共享的东西
修饰成员变量:
1.不属于对象,而是属于整个类, 随之类的加载而加载, 只会加载一次
2.可以直接通过类名调用
使用场景:当我们成员变量需要被所有对象共享的时候
修饰成员方法
1.不属于对象,而是属于整个类, 随之类的加载而加载, 只会加载一次
2.可以直接通过类名调用
使用场景:让方法调用起来更方便,不用创建对象就可以直接调用.
注意事项:
静态只能访问静态.因为静态的先加载, 而且可以直接类名来调用, 不用走构造函数!!!
public class A{
public A(){}
private int age = 20;
private static int a = 10;
public void method(){
sout(age);
sout(a);
}
public static void method1(){
sout(age);
sout(a);
}
}
/* a = new A();
a.method();//正确
a.method1();//不正确*/
//A a = new A();
A.method1();
Student s = new Student();
s.getName();
静态代码块!!!!!!
格式:
static{
写代码!!!!
}
位置: 定义在类中方法外
特点:
随着类的加载而加载,只会执行一次!!!!!!!!
作用:
后期经常用来加载一次性的配置文件和驱动等等!!!!
构造代码块:(了解!!!!!)
格式:
{
抽取多个构造函数中的共性内容!!!!!
}
位置: 定义在类中方法外
特点: 只要走了任何的构造函数,一定先走构造代码块
作用: 来抽取构造函数中的共性内容
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
