Java-OOP-Overwrite/Overloading of methods

重载

环境：在同一个类中 ，可以写多个同名的方法

结构：方法名一样 ，

返回值 ： 不一样的前提是 参数不一致（已经实现了重载 ）

访问修饰符

参数 ： 不一致

构造方法： 也可以通过参数的不一致来实现重载

所有的方法都是通过给定参数 来判断调用哪个方法

public class A {

    public A(String name){
        System.out.println("A1");

    }
    
    public A(String name,String id){

        System.out.println("A2");
    }


    public A(){
        System.out.println("A3");

    }

    // 方法重载
    public int test1(String name){

        return 10;
    }

    public String test1(String name,String id){

        return "10";
    }

    public void test1(){

    }

//    public int test1(){
//
//        return 10;
//    }


    public static void main(String[] args) {
        A a = new A();// A3
        a.test1();

        A a1 = new A("name01");
        a.test1("name01");

        A a2 = new A("name01","001");
        a2.test1("name01","001");
    }

}

重写

环境： 必须有继承关系 子类 与 父类

子类重写父类的方法： 方法结构需要一致 访问修饰符 返回值类型 方法名 参数一致

重写之后，在子类中，还是子类对象 都是优先调用子类重写的方法

构造方法： -- 不允许重写

子类会继承父类的属性方法 -- 初始化过程 - 子类会自动调用父类的构造方法

子类创建对象时会调用父类的构造方法 -- 如果父类的构造方法是空参数的 - 会默认调用父类的构造方法

如果父类的构造方法只有一个带参数的 ，子类必须写构造方法，并且在构造方法中调用父类的构造方法

class ClassSuperSuperSuper{
    int a;
    ClassSuperSuperSuper(int a){
        System.out.println(a+"空参数 ClassSuperSuperSuper");
    }
}
class ClassSuperSuper extends ClassSuperSuperSuper{
    int b;
    ClassSuperSuper(int a){
        super(a);
        System.out.println(a+"空参数 ClassSuperSuper");
    }
}
// 父类
public class ClassSuper extends  ClassSuperSuper{
    int c;
    // 具有唯一性 只有一个且带参数
    ClassSuper(int a){
        super(a);
        System.out.println(a+" 空参数 ClassSuper ");
    }

//    ClassSuper(){
//        System.out.println("空参数构造方法 ClassSuper");
//    }


    public void superMethod(){
        System.out.println("父类的方法");

    }
}
class ClassA extends  ClassSuper{
    int d;
    ClassA(int a){
        super(a);
        // 会进行初始化
        System.out.println(a+"子类ClassA");
    }


    // 重写父类的方法
    public void superMethod(){
        super.superMethod();
        System.out.println("子类重写的方法");

    }


    public static void main(String[] args) {
        ClassA ca = new ClassA(729);
        ca.superMethod();
//        ca.
    }
}

传值

class A{
    // 只有成员变量  
    int a;
		    
    // 参数 -在定义方法时 参数只声明 不赋值 -- 在方法调用的是 传值
    public void tA(B b1000){
      	int i;  
        System.out.print(a+b1.b+i);
    }
    
}

class B{
    int b;
    
    
}

class M{
    
   public static void main(String[] args){
       A  a1 = new A();
       a1.a=100;
       
       
       B b1 = new B();
       b1.b=a1.a;
       
       a1.tA(b1);
   }
}

窗体： 是否显示屏幕上

窗体对象 -- 数据 -- 内存开销

-- 不需要显示在屏幕上 -- Graphics 对它无用 -不会创建并开销内存

-- 需要显示在屏幕上 -- 一定需要 Graphics 沟通GPU来渲染窗体

-- paint 方法 都是 需要显示的时候才会调用

class A{

Graphics g;

int x;

drawLine(){

g.drawLine(x);

}

}

class Listener{

Graphics g;

A a = new A();// 只有一块 a1
B b;

    // 点击按钮 
    action(){

    a.g=getGraphics();

    }

	Shape[] shapes=new Shape[100];
	Shape shape;
   // 鼠标按下 
   mouseClicked(){
	 b = new B();
	  // shape = new Shape(x,y,"直线","color");
	  shape.drawLine(x,y,"直线"，color);
	 shapes[]=shape;
    // b=a;  
     [0]=b;
       
     b=a.g;

a.drawLine();-- g == null

}
}