java编程----继承

内存管理

1. 编写的xxx.java源码，编译为xxx.class字节码，由JVM（java解释器）来执行，JVM来对接不同的操作系统，实现一次编写，到处执行；
2. JVM向操作系统申请内存，并向程序提供内存管理；
3. JVM将内存分为，栈内存、堆内存、方法区内存；

堆：

• 存储所有new创建的对象（包含属性）；当对象的引用为0时，gc垃圾回收器会不定时回收垃圾对象；
• System.gc() 加速垃圾回收；（garbage collection）
  不用的对象及时赋值null，防止内存泄漏；
• 开发者不用关心内存管理， JVM自带的垃圾回收线程自动回收垃圾；

栈：

• 存储函数执行时所有的局部变量；
• 函数调用，压栈（分配栈帧），执行结束，弹栈（局部变量销毁）
   

成员变量：

• 类内，方法外；
• 有默认值；
• new对象时，连同对象一起存入堆中，回收对象则消失；

局部变量：

• 方法内，没有默认值；
• 调用方法时，存于栈中，方法执行结束则消失；
   
  方法区：
• 存储类的信息；
• .class字节码文件
• 每个对象有自己的成员变量属性；
• 所有对象共享类中的方法；
   

继承

• 类的继承使用extends，实现代码的复用；
• 被继承的类叫父类，继承的类叫子类；
• 子类继承后具有父类的功能 + 自己的功能；
• java只能单继承，只能有一个父类；
• 继承的传递性，依次传给子类；

class People{
	String name;
	int age;
	void run(){
		System.out.println("running...");
	}
}

class Man extends People{
	String dep;
	// 其他继承的属性、方法
}

 

super

• 当前类的父类；
• super.属性， 调用父类的属性；
• super.方法，调用父类的方法;
• super() 调用父类的构造方法;
• 子类中的构造方法默认调用父类的无参构造，即super();
• 可以自己实现子类构造方法中调用父类的构造方法，且必须放在第一行，此时不再调用父类的无参构造方法；
• 同一个包里的类名不能重复；
  

// 创建一个类文件TestExtend.java
package School;


public class TestExtend { // 类文件的入口---public公有类
    public static void main(String[] args){
        System.out.println("添加一个主类");

        // 测试
        ChinesePeople cp = new ChinesePeople();
        cp.run();
        cp.think();
        cp.tellMe();
        System.out.println("我来自: " + cp.addr + ", " + "我是" + cp.skin + "种人");
    }
}


//define parent class
class ParentExtend{ //定义类 大驼峰
    String addr;
    ParentExtend(){  //无参构造方法
        this("China");  // 调用有参构造
    }
    ParentExtend(String addr){
        this.addr = addr;  // 初始化当前对象的addr属性
    }

    void run(){
        System.out.println("从父类继承: 我可以跑路...");
    }

    void think(){
        System.out.println("从父类继承: 我正在思考...");
    }
}


//define subclass
class ChinesePeople extends ParentExtend{
    String skin;
    ChinesePeople(){
        // 默认调用父类的无参构造 即super()  来初始化

        // 子类本身的初始化
        this.skin = "yellow";
    }

    void tellMe(){ //定义方法、变量  小驼峰
        System.out.println("我是子类...");
    }
}

向上造型

• 子类的对象也是 父类类型的对象，即父类类型的引用可以指向子类对象；（向上造型）
• 此时，父类类型的引用只能调用父类本身的属性、方法；
• 父类类型的引用调用子类对象的属性、方法，会编译错误。

class Parent{
	int age;
	void parentFunc(){
		System.out.println("父类的方法");
	}
}

class Sub extends Parent{
	double height;
	void subFunc(){
		System.out.println("子类的方法");
	}
}

//创建子类对象
Sub sub = new Sub();
//向上造型
Parent p = new Sub();
p.parentFunc(); // 正确  父类的引用 只能调用自己的属性、方法
p.subFunc(); //错误

 

方法重写

Override:
子类从父类中继承的方法，重新编写代码逻辑。

• 方法名相同，参数列表相同；
• 返回值类型 <= 父类方法的返回值类型；void和基本数据类型必须相同，返回引用类型（类）时，重写后的返回值类型要么是当前类（=），要么是当前类的子类；
• 抛出的异常 <= 父类的方法；
• 向上造型只能调用本身类的属性、方法，但当方法被子类重写时，只能调用引用的对象的方法；

//创建源文件 TestOverride.java
package School;

public class TestOverride {
    public static void main(String[] args) {
        Child c = new Child();
        c.parentFunc();
    }
}


class P{
    String label;
    // 无参构造
    P(){}
    // 有参构造
    P(String label){
        this.label = label;
    }
    // 父类的方法
    void parentFunc(){
        System.out.println("父类的方法running...");
    }
}


class Child extends P{ // java只能单继承
    Child(){
        // 默认执行父类的无参构造 super()  完成初始化
    }

    // 继承的父类的方法，不满足自己的功能需求
    // 重写  <--代码逻辑
    void parentFunc(){ // 重写  函数名&参数列表 均相同
        super.parentFunc();// 继承父类的功能

        // 子类扩展的功能
        System.out.println("子类扩展的功能...");
    }
}

重写与重载区别：

• 重写函数名&参数列表均相同；重载仅仅函数名相同，参数列表不同。
• 重写发生在两个类；重载发生在一个类；
• 重写’运行期’绑定，看对象；重载"编译期"绑定，看类型；

 

package包

• 同包里不能有重名类；
• 同包的类可以直接引用；
• 包名小写，类名大写
• 不同的包之间，使用import导入类

package b; // b包
import a.Stu; // 导入a包中的Stu类（必须public）

public class Teacher{
	Stu stu;
	Teacher(){
		this.stu = new Stu();
	}
}

 

访问权限

• 数据私有，使用private修饰，只能在类内使用；
• 行为公开，使用public修饰，都可以使用；
• 保护使用protected修饰，同包内&子类使用；
• 默认（没有修饰词）本包内使用；
• 修饰类只能public (全局类) 或者 无修饰（保留类）
• 修饰属性、方法 以上修饰词均可以；
  
  对象访问public属性、方法，到处都可以；
  对象访问protected属性、方法，同包或子类可以；
  使用哪个类，就单独导入该类；
   

static关键字

• 实例变量属于每个对象，随对象一起存于堆中，obj.属性调用；
• static静态变量属于类，随类一起存入方法区，类名.属性调用；
• 方法区的类只初始化一次（使用该类时）；
• 静态变量相当于python的类属性，对象调用属性时，若没有则找类属性（静态属性），并且可以修改类属性的值；
• 所有的实例对象需要共同的数据时，考虑使用静态属性；
• 静态方法属于类，存于方法区，只一份，一般通过类调用（对象调用也不报错）；
• 静态方法中没有this关键字，所以不能访问实例变量，可以访问类属性（静态属性）；
• 与main同级的方法，都加static修饰；
• 与对象无关时，使用静态方法；
• static { xxx } 静态块，加载类时（声明类型时）执行（仅加载一次），常用于加载静态资源；

 

final关键字

• 修饰的变量是常量，一旦初始化不能修改；
• 修饰的方法不能重写；
• 修饰的类不能继承；