java笔记(5)

继承与访问权限
对于class类的权限修饰只可以用public default
1.public 都可以访问；2.default（包权限）只有 同一个包下的内部的类可以访问；

class Person{
	private String name;
	private int age;
	
	public void setName(String name){
		this.name = name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public String getName(){
		return this.name;
	}
	public int getAge(){
		return this.age;
	}
}
class Student extends Person {//继承父类的所有成员（成员属性，成员函数）
	private int grade;
	public void setGrade(int grade){
		this.grade = grade;
	}
	public int getGrade(){
		return this.grade;
	}
	public void test(){
		//System.out.println(age);//子类无法访问父类的私有变量
	}
}
public class PersonL {
	public static void main(String[] args){
		Student t = new Student();
		t.setName("lili");
		t.setAge(12);
		t.setGrade(1);
		System.out.println(t.getName());
		System.out.println(t.getAge());
		System.out.println(t.getGrade());
	}
}

访问权限测试

class T{
	private int a = 0;//只在当前所在类中有效
			int b = 1;//default,
	protected int c = 2;
	public int d = 3;
	public void func(){
		a = 9;
	}
}
class TT extends T{
	public void fun(){
		//a = 10;
		//System.out.println(a);
		//当子类和父类在同一个包中，子类可继承除private限制的所有成员
		System.out.println(b);
		System.out.println(c);
		System.out.println(d);
		T t = new T();
		t.b = 9;//可以访问default，位于同一个包下面
		
	}
}
// 注：当子类的父类不在同一个包中，子类只能继承父类中public protected限制的成员
public class TestAccess{
	public static void main(String[] args){
		T m = new T();
		m.b = 10;
	}
}

注：当子类的父类不在同一个包中，子类只能继承父类中public protected限制的成员
方法的重写（重新实现）
copy方法的声明，对具体内容进行所谓的重写
重写的新方法的访问权限不能比原方法的更严格

super

//super是一个类似于this的引用，是指向父类的引用
class Father {
	public int value;
	public void f(){
		value = 100;
		System.out.println("FatherValue:"+value);
	}
}
class Son extends Father {
	public int value;
	public void f(){
		super.f();//引用父类的方法 
		//打印value:100(父类的)
		value = 200;
		System.out.println("SonValue:"+value);//子类自己的value 200
		System.out.println("FatherValue:"+super.value);//引用父类value 100
	}
}
public class TestSuper {
	public static void main(String[] args){
		Father father = new Father();
		father.f();
		Son son = new Son();
		son.f();
	}
	
}

如何使用？

//继承中的构造方法
class SuperFunc {
	int n = 10;
	SuperFunc(){
		System.out.println("SuperFunc");
		
	}
	SuperFunc(int n){
		System.out.println("SuperFunc"+n);
	}
	
}
class Func extends SuperFunc {
	int n = 12;
	Func(){
		super();
	}
	Func(int n){
		super();
		//1.若不写super会自动找父类中无参的构造方法;
		//2.并且子类执行时一定会执行父类的构造方法
		//3.若没有子类的无参构造方法,则编译错误
		//4.super语句一定写在方法的第一行
		System.out.println("SuperFunc"+n);
	}
}
public class TestStruct {
	public static void main(String[] args){
		Func f = new Func();
		Func f1 = new Func(12);//
	}
}

class A {
	public void print(String s){
		System.out.println(s);
	}
	A() {
		print("A()");
	}
	public void f() {
		print("func A");
	}
}
class B extends A {
	B() {//自动调用A中无参构造
		print("B()");
		
	}
	public void f(){//相当于方法的重写
		print("funcB");
	}
	
}
public class TestPrint {
	public static void main(String[] args){
		B b = new B();
		b.f();
//		结果：
//		A()
//		B()
//		funcB
	}
}