Java中的代码块和继承
代码块
代码块分类:
1.代码块:限制变量的作用域(生命周期)
书写位置:在方法中
2.构造代码块(在开发中 很少使用)
书写位置: 在类中 方法
调用时机: 如果你有构造代码块 系统会帮你调用
帮你在创建对象之前调用 每次创建对象 都会调用
3.静态代码块(一定是被static修饰的)
静态代码块 依赖类 随着类的加载而加载
注意: 只加载一次(系统只调用一次 不管你创建了多少对象)
应用场景: 加载驱动(数据库驱动 JDBC)
4.同步代码块(多线程)
例如:
public static void main(String[] args) {
Person person = new Person();
person.setName("吴彦祖");
person.setAge(18);
person.sayHi();
Person person2 = new Person("吴奇隆",18);
person2.sayHi();
}
}
class Person{
private String name;
private int age;
static {
System.out.println("我是Person类的静态代码块");
}
{
this.sleep();
System.out.println("我是构造代码块");
}
public Person(){
System.out.println("我是无参数的构造方法");
}
public Person(String name, int age) {
this.name = name;
this.age = age;
System.out.println("我是有参的构造方法");
}
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
继承的弊端:
1.继承时 可以把多个类中 相同的功能或方法抽取出来
重新构造一个类出来 把这些类 建立继承关系
2.建立继承关系的同时 一定要符合逻辑(切记不要为了继承而继承)
注意: 如果是继承关系 一定符合 什么是什么(项目经理 是员工 子类 是 父类)
继承的写法:
class 子类 extends 父类{
}
例如:
public static void main(String[] args) {
Cat cat = new Cat();
cat.name = "大咪";
System.out.println(cat.name);
cat.kind = "中华田园";
System.out.println(cat.kind);
cat.color = "白色";
System.out.println(cat.color);
cat.catechMice();
cat.sleep();
}
class Animal{
String name;
String color;
String kind;
public void sleep() {
System.out.println("会睡觉");
}
}
class Cat extends Animal{
public void catechMice() {
System.out.println("抓老鼠");
}
}
class Dog extends Animal{
public void chewBones() {
System.out.println("啃骨头");
}
}
Java中的继承
注意:
1.Java 只允许单继承(多继承可以使用借口来间接实现)
2.Java中 允许 多层继承(爷爷 父亲 儿子 孙子 重孙...)
Java中 最顶层的父类(最基础的类) Object类
如果我这个类 没有写 继承哪个父类 默认就是继承Object类
1. 如果我要使用 这些类中 共有方法(属性)
创建当前继承中 最顶端类 去使用
2. 如果我要使用 这些类中 特有方法(属性)
创建当前继承中 最末端的 类 去使用
class A{
String name;
}
class B extends A{
}
class C extends B{
public void call() {
System.out.println("会叫爷爷");
}
}
构造方法能否被继承
构造方法能被继承么?
答案是 构造方法不能被继承
例如:
public static void main(String[] args) {
Son son = new Son();
son.name = "儿子";
son.sayHi();
System.out.println("-------------");
Son son2 = new Son("小明");
son2.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();
System.out.println("我是Son类无参的构造方法");
}
public Son(String name) {
super();
this.name = name;
System.out.println("我是Son类有参的构造方法");
}
}
为了保证继承完整性 在你创建子类对象的时候
如果你不调用父类的构造方法 那么
系统会默认帮你去调用 父类的无参构造方法
关键字 super 和 this
super 关键字
super 代表的时: 父类的对象
super调用对象 super.对象
调用方法 super.方法
super(); 调用的父类无参构造方法
this(); 调用的本类构造方法
例如:
public static void main(String[] args) {
TestB b = new TestB();
b.fun();
}
class TestA{
int num1 = 10;
int num2 = 20;
}
class TestB extends TestA{
int num1 = 30;
public void fun() {
System.out.println(this.num1);
System.out.println(this.num2);
System.out.println(super.num1);
}
}
如果父类没有无参构造方法怎么办?
如果父类没有无参构造方法怎么办?
例如:
class Phone{
String name;
public Phone(String name) {
this.name = name;
}
}
class MI extends Phone{
public MI() {
super("Note2");
}
public MI(String name) {
super(name);
this.name = name;
}
}
建议: 不管是父类 还是子类 构造方法 一定要 写全 避免 出现问题
方法的重写
父类 和 子类 的方法 能不能重名?
是可以的
这样叫做 方法的重写
注意:
1.方法声明完全一致的时候 叫方法的重写
2.方法的重写 建立在类与类之间有继承关系(子类 重写 父类 的 方法)
例如:
public static void main(String[] args) {
IOS8 ios8 = new IOS8();
ios8.siri();
System.out.println(ios8);
System.out.println(ios8.toString());
}
}
class IOS7{
public void call() {
System.out.println("打电话");
}
public void siri() {
System.out.println("说英文");
}
}
class IOS8 extends IOS7{
@Override
public void siri() {
super.siri();
}
@Override
public String toString() {
return "哈哈";
}
}
当成员变量用 private修饰的时候 成员变量还能继承么?
当成员变量用 private修饰的时候 成员变量还能继承么?
例如:
public static void main(String[] args) {
Student student = new Student("苏茜孟", 21, 17120404);
System.out.println(student);
}
class People{
private String name;
private int age;
public People(){
}
public People(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 eat() {
System.out.println("吃饭");
}
@Override
public String toString() {
return "姓名: " + name + " " + "年龄: " + age + " ";
}
}
class Teacher extends People{
public Teacher() {
}
public Teacher(String name, int age) {
super(name, age);
}
public void teach() {
System.out.println("教书");
}
@Override
public String toString() {
return super.toString();
}
}
class Student extends People{
private int id;
public Student() {
}
public Student(String name, int age, int id) {
super(name, age);
this.id = id;
}
public void study() {
System.out.println("学习");
}
@Override
public String toString() {
return super.toString() + "学号: " + id;
}
}
Day.10