1.1 成员变量的使用
public class Test1_UseExtends {
public static void main(String[] args) {
// 创建子类对象测试
Erzi z = new Erzi();
// z.eat();
z.study();
}
}
//创建父类
class Baba{
int sum = 0;
int count = 20;
public void eat() {
int count = 10;
System.out.println(count); // 10
//现在成员变量和局部变量同名啦,想使用成员变量要用this关键字
System.out.println(this.count); // 20
System.out.println(sum); //0
}
}
//创建子类
class Erzi extends Baba{
public void study() {
//在子类中想要使用父类的成员变量count
//super就相当于在底层帮你创建了父类对象,super代表了父类对象的一个引用
//Baba super = new Baba();
System.out.println( super.count ); //20
}
}
1.2 成员方法的使用
- 继承方法,特有方法,重写方法
public class Test2_UseExtends2 {
public static void main(String[] args) {
//创建子类对象测试
Zi zi = new Zi();
zi.eat();//如果没有发生方法重写,使用的是父类的实现方式;如果发生了方法重写,使用的是子类的实现方式。
zi.study();//使用子类的特有方法
}
}
//创建父类
class Fu{
public void eat() {
System.out.println("爸爸在吃肉肉");
}
}
//创建子类
class Zi extends Fu{
//子类继承父类后,想要 修改 父类的原有功能 --- 方法的重写现象 -- 尽量不修改源码
//重写的要求:发生继承关系 + 要修改原有业务 + 在子类中的方法声明和父类一模一样
//子类在进行重写时,必须有足够的权限(子类权限>=父类权限)
public void eat() {
//super.eat();
//重写真的没有影响父类的原有功能吗?--- 没有影响
System.out.println("儿子在喝汤");
}
//提供特有方法
public void study() {
System.out.println("儿子在学习");
}
}
1.3 构造方法的使用
- 子类创建对象时,默认会去访问父类的无参构造方法
- 在子类构造方法的第一行,都有一条默认的语句:super();this()
- 父类没有无参构造时,可以用super调用父类的其他构造
public class Test3_UseExtends3 {
public static void main(String[] args) {
//创建子类对象测试
Zi2 z= new Zi2();//干了两件事:先执行父类的无参构造,再执行子类的构造
}
}
//创建父类
class Fu2{
//当父类没有无参构造时(只提供了含参构造时),子类还能创建对象吗? ---
public Fu2(int a) {
System.out.println("Fu2()..."+a);
}
}
//创建子类
class Zi2 extends Fu2{
public Zi2() {
//super();
//在子类的构造方法中,默认会存在super(),会自动去找父类的无参构造
//当父类没有无参构造时(只提供了含参构造时),子类创建对象时无法使用super(),怎么办? ---可以调用父类的含参构造
//super关键字使用在 构造方法中 ,位置上必须是第一条语句,类似于this
super(10);
System.out.println("Zi2()...");
}
//父类构造方法能继承吗? -- 不能
// public Fu2() { System.out.println("Fu2()..."); }
}
2 static
- 是java中的一个关键字
- 用于修饰成员(成员变量和成员方法)
特点:
随着类的加载而加载;
只加载一次,就会一直存在,直到类消失就一起消失了;
优先于对象加载;
被所有对象所共享;
可以直接被类名调用;
静态代码块、构造代码块、局部代码块:
静态代码块:在类加载时就加载,并且只被加载一次,一般用于项目的初始化。
构造代码块:在创建对象时会自动调用,每次创建对象都会被调用。
局部代码块:方法里的代码块。
3 final
概念:
1、 是java提供的一个关键字
2、 final是最终的意思
3、 final可以修饰类,方法,成员变量
- 初衷是因为:java出现了继承后,子类可以更改父类的功能,当父类功能不许子类改变时可以利用final关键字修饰父类。
特点:
1、 被final修饰的类,不能被继承
2、 被final修饰的方法,不能被重写
3、 被final修饰的变量是个常量,值不能被改变
4、 常量的定义形式:final 数据类型 常量名 = 值
4 多态
概念:
1、多态指同一个实体同时具有多种形式。 它是面向对象程序设计(OOP)的一个重要特征。
2、主要是指同一个对象,在不同时刻,代表的对象不一样,指的是对象的多种形态。
3、好处是可以把不同的子类对象都当作父类来看,可以屏蔽不同子类对象之间的差异,写出通用的代码,做出通用的编程,统一调用标准。
特点:
1、 多态的前提1是继承
2、 多态的前提2是要有方法的重写
3、 父类引用指向子类对象,如:Animal a = newDog(); – 小到大,向上转型
4、 多态中,编译看左边,运行看右边
public class Test8_ManyTai {
public static void main(String[] args) {
//创建子类对象测试
Dog d = new Dog();
d.eat();//狗吃s,执行的是子类的功能呢还是父类的功能呢?-- 重写后的子类的功能
//创建多态对象测试
Animal a = new Dog();//口诀1:父类引用 指向 子类对象--多态
//口诀2:编译看左边,运行看右边
//编译看左边: 是指 想要保存成功,只能调用左边也就是父类提供的功能
//运行看右边: 是指 程序的运行结果 要使用右边也就是 子类 的实现方式
a.eat();//狗吃s
}
}
//创建父类
class Animal{
public void eat() {
System.out.println("吃啥都行");
}
}
//创建子类
//多态前提:继承 + 重写
class Dog extends Animal{
//重写:方法声明一样但是方法体不一样
public void eat() {
System.out.println("狗吃s");
}
}