栋哥带你学Java类的继承和方法的重写

1.局部代码块:限制变量的作用域(生命周期)
书写位置: 在方法中.
2.构造代码块(在软件开发中很少使用)
书写位置:在类中方法外.
调用时机:如果你有构造代码块 系统会帮你调用 ,帮你在创造对象之前调用,每次创建对象都会调用.
3.静态代码块(一定是被static修饰的)
静态代码块:依赖类,随着类的加载而加载.
注意:只加载一次(系统只调用一次 不管你创建多少对象).
应用场景:U盘装载驱动程序
加载驱动(数据库驱动 JDBC)
4.同步代码块(多线程)
例子:
public class Demo {
public static void main(String[] args) {
//      {
//          System.out.println("我是局部代码块");
//      }
Person p1 = new Person();
p1.setName("李四");
p1.setAge(19);
p1.sayHi();
Person p2 = new Person("张三", 18);
p2.sayHi();
}
}
class Person {
private String name;    // 人名
private int age;    // 年龄
{
// 比如 我每个对象 都会调用同一个方法 这时可以使用
System.out.println("我是构造代码块");
}
static  {
// 比如 我每个对象 都会调用同一个方法 这时可以使用
System.out.println("我是静态代码块");
}
// 构造
public Person() {
System.out.println("我是无参数的构造方法");
}
public Person(String name) {
this.name = name;
}
public Person(int age) {
this.age = age;
}
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;
}
public void sayHi() {
System.out.println("我叫" + name + ",今年" + age + "岁~");
}
// 睡觉
public void sleep() {
System.out.println("睡觉的方法");
}
}

继承的特点:
1.减少你的代码量(工作量)
2.让类与类之间产生关系(父子)
注意:继承时可以把多个类中相同的功能或方法抽取出来重新构造一个类出来,然后把这些类建立继承关系.
继承关键字:extends
继承写法:
class 子类 extends 父类{
}
public class Demo {
public static void main(String[] args) {
// 创建一个猫
// 子类继承 父类 方法和属性
Cat cat = new Cat();
cat.name = "汤姆";
cat.kind = "灰猫";
cat.hitMouse();
}
}

class Animal {
String name;
String color;
String kind;

// 睡觉
public void sleep() {
System.out.println("会睡觉");
}
}

class Cat extends Animal{
// 抓老鼠
public void hitMouse() {
System.out.println("抓老鼠");
}
}

class Dog extends Animal{
// 啃骨头
public void eatBone() {
System.out.println("啃骨头");
}
}
注意:
1.java中只允许单继承(多继承可以使用接口来间接实现).
2.java中允许多层继承.
3.java中最顶层的父类(最基础类)Object类
如我这个类没有写继承哪个父类,默认就是继承Object类
public class Demo03 extends Object{
public static void main(String[] args) {
B b = new B();
b.name = "爸爸类";
System.out.println(b.name);
C c = new C();
c.name = "我是C类";
c.fun();
}
}

//  A类是爷爷类 B类是父类 C类是孙子类
//  A类中有name C类中 会叫爷爷
class A {
String name;
}
class B extends A{

}
class C extends B{
public void fun() {
System.out.println("会叫爷爷");
}
}
注意:测试类中的extends Object可写可不写.
Java中,父类的构造方法不能被继承.
为了保证继承的完整性,在你创建子类对象的时候,如果你不调用父类的构造方法,那么
系统会默认帮你去调用父类无参构造方法.反之则调用父类有参构造方法.
public class Demo {
public static void main(String[] args) {
//      Son son = new Son();
//      son.name = "儿子";
//      son.sayHi();
Son son = new Son("儿子");
son.sayHi();
}
}
class Father {
String name;
// 无参 有参构造方法
public Father() {
System.out.println("我是爸爸类无参的构造方法");
}

public Father(String name) {
this.name = name;
System.out.println("我是爸爸类有参的构造方法");
}
public void sayHi() {
System.out.println(name);
}
}
class Son extends Father {
// 无参构造
public Son() {
// 如果你没有在子类的构造方法中  调用父类构造方法
// 系统会默认给你的子类构造方法中 添加一行代码
super(); // 调用父类的 无参构造方法
// super这个关键字相当于父类的对象
System.out.println("我是儿子类无参构造方法");
}
// 有参构造
public Son(String name) {
super(); // 系统帮你默认调用父类的构造方法
this.name = name;
System.out.println("我是儿子类有参构造方法");
}
}
super关键字:
1.super代表是父类的对象.
2.super调用对象super.对象.
3.super调用方法super点方法();
4.super(); 调用的父类构造方法.
5.this(); 调用的时本类的对象.
注意:super必须写在子类构造方法的第一句,比如子类里面声明了一个父类没有的属性,那么在子类的有参构造方法中this.属性 = 参数;这句代码必须写在super();的后面,不然会报错.报错的原因就是,实例化一个对象的时候,子类先调用父类的构造方法,如果顺序反了就违背了概念.如果父类没有无参的构造方法,那么在子类中,super()的括号里必须要写传入的参数名.所以,不管父类还是子类,构造方法一定写全,避免出现问题.
子类的构造方法中,如果你什么都不写,会默认调父类无参的构造方法.如果父类没有无参构造,就证明父类当中一定有有参的构造方法,无论有参还是无参,子类的构造方法中
必须要调用一个,必须手动指定一个有参构造方法取调用.

方法重写:
1.方法声明完全一致的时候叫方法重写.
2.方法的重写建立在类与类之间有继承的关系.
Override(重写) 和 Overload(重载) 的区别
1.重写的继承:需要继承关系
重载:在同一个类中
2.重写需要 方法的声明完全一致
重载: 只跟参数有关
public class Demo07 {
public static void main(String[] args) {
IOS8 ios8 = new IOS8();
ios8.siri();
}
}

class IOS7 {
public void call() {
System.out.println("打电话");
}

public void siri() {
System.out.println("说英文");
}
}

class IOS8 extends IOS7 {
String name;
// 方法的重写:对父类的方法 进行一个功能上的升级
public void siri() {
// 中英文 都会说
super.siri();   // 调用父类的方法
System.out.println("说中文");
}
}