子类实例化、重载-重写、this、super、final、static关键字

目录

子类实例化

访问修饰符--访问控制权限

public--公有的

private--私有的

默认/缺省/友好friendly/包

    protected--保护的

重载-重写

重载overload

重写 override

向上转型

向下转型

this、super、final、static关键字

this关键字

super关键字

final关键字

static关键字

package demo211201;

子类实例化

public class TestA {
    public static void main(String[] args) {
        new D().print();;// 子类实例化时，必须先实例化父类，再实例化子类

    }
}

class A {
    A() {
        System.out.println("A");
    }
}

class B extends A {
    B() {
        System.out.println("B");
    }
}

class C {
    int a = 1;

    C() {
        System.out.println("----" + a);
        a = 2;
    }
}

class D extends C { //new D().print();
    D() {
        System.out.println("+++++" + a);
        a = 3;
    }

    void print() {
        System.out.println("====" + a);
    }
}

输出结果：

---

---

package demo211201;

public class TestB {

访问修饰符--访问控制权限

public--公有的

    // 作用:对所有类可见，即:可以在当前工程任意文件中访问使用
    // 主要使用位置:类（文件）、成员（变量、方法）
    // public修饰的外部类必须与文件同名，且该文件中仅有一个修饰的外部类    

package demo211201;
public class TestB {
    public void f1() {

    }
}

package demo211201;

public class TestC {
    public static void main(String[] args) {
        TestB tb = new TestB();
        tb.f1();//(同工程)
    }

}

 

private--私有的

    // 作用:在当前类（文件）可见.即：可在当前类体中访问使用
    // 主要使用位置:成员（变量、方法）
    // ps：不能修饰外部类

package demo211201;
public class TestB {
    private void f2() {

    }
}

package demo211201;

public class TestC {
	public static void main(String[] args) {
		TestB tb = new TestB();
		tb.f1();
		tb.f2();//(不可使用，不在同一类体)
	}

}

默认/缺省/友好friendly/包

    //作用：对同包内可见。即：可以在当前包中任意文件里访问
    // 主要使用位置:类（文件）、成员（变量、方法）

package demo211201;
public class TestB {
      void f3() {

    }
}

package demo211201;

public class TestC {
	public static void main(String[] args) {
		TestB tb = new TestB();
		tb.f3();//(同包内)
	}

}

    
protected--保护的

    //作用：对同包内和所有的子类可见
    //主要使用位置：成员
    //ps:不能修饰外部类

package demo211201;
public class TestB {
  protected void name() {
        
    }
}

package demo211201;

public class TestC {
	public static void main(String[] args) {
		TestB tb = new TestB();
		tb.name();//(同包内可以使用)
	}

}

    //子类与其基类在相同包中：
    //被声明protected的成员能被同包中的任薏类访问
    //子类与其基类在不在同包中：
    //在子类中，子类实例实例可以访问其从基类继承而来的protected
    //而基类实例不能访问protected

---

---

package demo211201;

重载-重写

重载overload

//重载overload 是在一个类里面，方法名字相同，参数列表不同

public class TestD {
    void test() {   
    }
    void test(int a) {  
    } 
}

---

---

package demo211201;

import org.junit.Test;

public class TestE {

重写 override

    // 子类对父类允许访问的方法的实现过程进行重新定义
    // 返回类型和参数都不能改变
    // 外壳不变+核心重写
    // 好处在于子类可以根据需要，自己定义特定的行为动作。

    // 重写规则
    // 方法的重写规则
    // 参数列表必须完全与被重写方法的相同;
    // 返回类型必须完全与被重写方法的返回类型相同;
    // 访问权限不能比父类中被重写的方法的访问权限更低。例如:如果X类的一个方法被声明为public,
    // 那么在子类中重写该方法就不能声明为protected。
    // 父类的成员方法只能被它的子类重写。
    // 声明为final的方法不能被重写。
    // 声明为static的方法不能被重写，但是能够被再次声明。
    // 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
    // 子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
    // 重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛
    // 出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常,反之则可以。
    // 构造方法不能被重写。
    // 如果不能继承一个方法，则不能重写这个方法。
 
    // 两同两小一大：
    // 1-两同
    // 方法名称和参数
    // 2-两小
    // 子类方法返回值类型比父类方法返回值更小或相同
    // 子类方法定义抛出的异常应比父类方法定义抛出的异常类更小或相同
    // 3-一大
    // （子类比父类）访问权限-更大+相同  

向上转型

	class Animal {
		int p = 1;

		public void move() {
			System.out.println("动物可以移动");
		}

		public void a() {
			System.out.println();
		}
	}

	class Dog extends Animal {
		int p = 2;

		public void move() {
			System.out.println("狗可以跑");
		}

		public void b() {
			System.out.println();
		}

		@Override
		public String toString() {
			return "aaaaaaaaaaaaaa";
		}

	}

    @Test
    public void test1() {
        Animal animal=new Animal();
        animal.a();
        animal.move();
    }

输出结果：

@Test
	public void test2() {
		Dog dog = new Dog();
		dog.a();
		dog.b();
		dog.move();
		System.out.println(dog.p);
	}

 输出结果：

@Test
	public void test3() {
		Animal a1 = new Dog();// （自动）向上转型
		a1.a();
		a1.move();
		System.out.println(a1.p);

		Object d = new Dog();
		System.out.println(d.toString());
		ArrayList<String> list = new ArrayList<>();
		List<String> list1 = new ArrayList<>();
		// 面向接口的变成方式
	}

    // 向上转型：下级对象赋值给上级变量
    // 赋值条件：在发生直接或间接继承（实现）上下级关系的时候（即，存在上下级关系）
    // 调用规则：仅能调用变量类型的成员（方法+变量）
    // ***若调用的是重写的方法，则调用执行的是子类中该重写的方法***

 输出结果：

@Test
	public void test4() {
		Animal a = new Animal();
		Dog b = new Dog();
		Animal c = new Dog();
		Object d = new Dog();
		System.out.println(b instanceof Dog);//true
		System.out.println(b instanceof Animal);//true
		System.out.println(d instanceof Dog);//true
		System.out.println(a instanceof Dog);//false
		//instanceof左侧变量的对象，能否给右侧类型的变量赋值
		System.out.println(c instanceof Dog);//true
		System.out.println(a.p);//1
		System.out.println(b.p);//2
		System.out.println(c.p);//1
		//System.out.println(d.p);//错误
	}
}

输出结果：

向上转型例题：

向下转型

	@Test
	public void test6() {

		Animal c = new Dog();// （自动）向上转型

		int t0 = 100;
		long t1 = t0;
		int t2 = (int) t1;

		Dog e = (Dog) c;// （强制）向下转型
		// e.p;
		// e.b();
		// e.a();
		e.move();// 狗可以跑

	}

 输出结果：

class Temp {
	Object test() {
		return null;
	}
}

---

---

package demo211201;

this、super、final、static关键字

this关键字

public class TestF {
    // this:当前对象的引用，用来访问当前对象中的成员
    // this代指=调用(this所在的方法)的对象

    public void setTestThis(int testThis) {
        this.testThis = testThis;
    }

    private int testThis = 100;

    public int getTestThis() {
        return testThis;
    }

    public static void main(String[] args) {
        TestF t1 = new TestF();
        t1.setTestThis(200);
        System.out.println(t1.getTestThis());

        TestF t2 = new TestF();
        t2.setTestThis(300);
        System.out.println(t2.getTestThis());

        TestF t3 = new TestF(500);
        System.out.println(t3.getTestThis());

        TestF t4 = new TestF();
        System.out.println(t4.getTestThis());
    }

    public TestF() {
//        this(400);
    }

    public TestF(int testThis) {
        this();
        this.testThis = testThis;
        System.out.println(testThis);
        
        
    }

}

this关键字

---

---

package demo211201;

super关键字

import org.junit.Test;

public class TestG extends TestGSuper {

    private int id = 0;
    
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public TestG(int id) {
        super(111000);//父类有参必须写且赋值
        //super();//调用父类无参构造方法
        this.id = id;
    }


    // super:上级对象的引用+用来访问上级对象中的成员
    // super代指=调用super所在的方法的对象在实例化时先实例化父类的对象
    public static void main(String[] args) {
        TestG t = new TestG(1000);
        t.temp();
    }

    public void temp() {
        System.out.println(getText1());
        System.out.println(this.getText1());
        System.out.println(super.getText1());
    }

    @Override
    public int getText1() {
        return 10;
    }
}

class TestGSuper {

    public TestGSuper(int test1) {
        super();
        this.test1 = test1;
    }

    private int test1;

    public int getText1() {
        return test1;
    }

    public void setText1(int text1) {
        this.test1 = text1;
    }

}

---

---

final关键字

---

---

package demo211201;

static关键字

import org.junit.Test;

public class TestJ {
    public static void main(String[] args) {
//        TestJ.a = 101;// 标准调用格式
//        f1();// 省略调用格式

    }

    void test() {
        TestJ t = new TestJ();
        t.b = 201;// 标准调用格式
        t.f2();// 省略调用格式
        System.out.println(b);
        System.out.println(this.b);
    }

    // static 功能修饰符
    static int a = 100;
    int b = 200;

    static void f1() {

    }

    void f2() {

    }

    @Test
    public void test3() {
        TestJ t1 = new TestJ();
        TestJ t2 = new TestJ();
        System.out.println(t1.b);
        System.out.println(t2.b);
        t1.b = 102;
        t2.b = 202;
        System.out.println(t1.b);
        System.out.println(t2.b);
        // 同个类的不同对象中的实例变量互不受影响

        System.out.println(t1.a);
        System.out.println(t2.a);
        System.out.println(TestJ.a);
        t1.a = 303;
        t2.a = 404;
        System.out.println(t1.a);
        System.out.println(t2.a);
        System.out.println(TestJ.a);
        // 两个类的不同对象中的静态变量公用的是同一个
    }
}

class E {
    private static void testMethod() {
        System.out.println("testMethod");
    }

    public static void main(String[] args) {
        E e1 = (E) null;// 没对象
        e1.testMethod();// testMethod
        ((E) null).testMethod();// testMethod
//        e1.test();//空指针异常
        E e2 = null;
        e2.testMethod();// testMethod
    }

    private void test() {
        System.out.println("test");
    }

}

---

---

 package demo211202;

public class TestB {
    public static void main(String[] args) {
        TestB1 t1= new TestB1();
        t1.print();//haha
        TestB2 t2= new TestB2();
        t2.print();//hoho
        TestB1 t3= new TestB2();
        t3.print();//haha    
    }
}

//当子类中出现了与父类static修饰的方法同名同类型同参数列表不降低访问权限的方法（即类似重写的书写规则）
//（即类似重写的书写规则）这并不是代表子类重写父类的static的方法
//而是，子类的该方法只是将父类的方法进行了隐藏，而非重写，这两个方法没有关系
//父类指向子类对象时，只会调用父类的静态方法

class TestB1{
    static void print() {
        System.out.println("haha");
    }
}

class TestB2 extends TestB1{
    static void print() {
        System.out.println("hoho");
    }
}