精华内容
下载资源
问答
  • 主要介绍了C#实现获取不同对象名称相同属性的方法,涉及C#操作类与对象属性的相关技巧,具有一定参考借鉴价值,需要的朋友可以参考下
  • 2.1 子类重写的方法必须和父类被重写方法具有相同的方法名称,参数列表 方法的重载是同类下,同名方法参数列表不同 2.2子类重写的方法返回值类型不能大于父类被重写方法的返回值类型 1,父类返回值类型为void,...

    /*

    • 方法的重写
    • 1,定义:在子类中可以根据需要对从父类中继承来的方法进行改造,也称为方法的重置,覆盖。
    • 在程序执行时,子类的方法会覆盖父类的方法。
    • 2,重写的规则
    • 2.1 子类重写的方法必须和父类被重写方法具有相同的方法名称,参数列表
    • 方法的重载是同类下,同名方法参数列表不同
    • 2.2子类重写的方法返回值类型不能大于父类被重写方法的返回值类型
    • 1,父类返回值类型为void,子类重写的返回值类型也是void
    • 2,父类被重写方法的返回值类型是A(引用数据类型),则子类重写方法的返回值类型可以是A类或A的子类。
    • 3,父类被重写方法的返回值类型是基本数据类型。则子类重写方法的返回值类型是相同的基本数据类型。
    • 2.3子类重写方法的访问权限不能小于父类被重写方法的访问权限
    • 子类不能重写父类中private权限的方法,子类可以创建方法名与参数列表与父类中private方法相同的方法。
    • 但这不会被认为是重写
    • 方法中调用的方法如果是重写的,则执行子类中重写的方法。
    • 2.4子类方法抛出的异常类型不能大于父类被重写方法的异常类型。
    • 3,说明
    • 子类与父类中同名同参的方法必须同时声明为非static的(即重写的情况)。或者同时声明为
    • static的(不是重写),因为static 的方法属于类的,子类无法覆盖父类的static方法。
    • 实际开发常常直接复制父类方法,然后重写方法体,权限与返回值不用改变。
    • 在eclips中可以用alt+/选择自动生成方法重写结构,然后更改方法体即可。
    • super关键字的使用:
    • super可以用super.属性或者super.方法的方式来显示的调用父类的属性方法和构造器,但通常会省略super。
    • 1.当子类和父类中定义了同名的属性时,想要在子类中调用父类的属性,必须显式的使用super关键字表明调用的是父类的属性。
    • 2.当子类中重写了父类的方法后,想要在子类中调用父类被重写的方法时,必须显式的使用super关键字表明调用的是父类的被重写的方法。
    • 对于没有重写的方法,使用this与super声明效果相同。因为this调用的成员在子类中找不到时会到父类中去找。
    • 注意super的追溯不限于直接父类
    • 3,super调用构造器:
    • 3.1可以在子类的构造器中显式的使用super(形参列表)的方式,调用父类中指定的构造器。
    • 3.2super调用构造器与this一样只能放在首行。不能同时调用this(形参列表)和super(形参列表)声明的构造器。
    • 3.3子类的构造器默认调用父类的空参构造器super()(即使删除也会调用),也会执行父类空参构造器中设定的程序。
    • 3.4推理因为类的n个构造器中至多有n-1个构造器首行使用this(形参列表)方式调用其他构造器,
    • 根据3.2和3.3,类的构造器中至少有一个构造器使用super(形参列表)的方式调用父类的构造器。
    • 3.5如果父类中没有空参构造器,子类构造器无法调用,会报错。
    • 子类的对象实例化过程分析;
    • 1,从结果看,子类继承父类后就获取了父类中声明的属性和方法,创建子类的对象就会在堆中加载所有直接或间接父类中声明的属性。
    • 2,从过程看,当我们通过子类的构造器创建对象时,一定会直接或间接的调用其父类的构造器,进而调用父类的父类的构造器直到
    • 调用java.lang.Object类的构造器,正因为加载过这些构造器,所以内存空间中才会有直接或间接父类的属性和方法。子类对象
    • 才可以去调用。
    • 3,创建子类对象时虽然调用了父类的构造器,但过程中只创建了一个对象,即子类new 的对象。

    */

    package object_chapter2;
    
    public class Object_Override {
       public static void main(String[] args) {
    	Student s = new Student();
    	new SubStudent();
    	s.setAge(35);
    	System.out.println(s.getNewAge());
    	System.out.println(s.getNewAge1());
    	s.readInfo();
    	
    		//测试向下类型转换
    	People2 p = new SubStudent();
    	p.eat();
    	System.out.println(p instanceof SubStudent);//显示true
    	SubStudent ss = (SubStudent) p;//转换成功,可以调用孙类的方法
    	ss.cry();
    	Student ss1 = new Student();
    	System.out.println(ss1 instanceof SubStudent);//显示false
    	SubStudent ss2 = (SubStudent)ss1;//会报错
    }
    }
    class People2{
    	public String name = "defaultname";
    	private int age = 28;
    	int number = 1000;
    	protected int argus = 11;
    	public String ID = "身份证号13311113331313";
    	
    	public People2() {
          System.out.println("初代构造器");
    	}
    
    	public People2(String name, int age, int number, int argus,String ID) {
    		this.name = name;
    		this.age = age;
    		this.number = number;
    		this.argus = argus;
    		this.ID = ID;
    	}
    	
    	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 int getNumber() {
    		return number;
    	}
    	public void setNumber(int number) {
    		this.number = number;
    	}
    	public int getArgus() {
    		return argus;
    	}
    	public void setArgus(int argus) {
    		this.argus = argus;
    	}
    	private void show() {
    		System.out.println("秀儿");
    	}
    	public void say() {
    		System.out.println("Hello.");
    	}
    	public int getNewAge() {
    		say();//如果子类重写此方法则子类的对象调用此方法(getNewAge())时使用子类重写的方法
    		show();//私有方法不能被重写,子类对象调用此方法(getNewAge())时使用父类方法
    		return age - 2;
    	}
    	public Object getInfo(){
    		return null;
    	}
    	public double Info(){
    		return 2.2;
    	}
    	public void setInfo() {
    		System.out.println("墙都不服");
    	}
    
    }
    class Student extends People2{
    	public String ID = "学号:23";
    	
    	public Student() {
    		System.out.println("一代构造器");
    	}
    	
    	public Student(String name, int age, int number, int argus,String ID,String ID1) {
    		super(name, age,number,argus,ID);
    		this.ID = ID1;
    	}
    
    	public void show() {
    		System.out.println("秀你一脸");
    	}
        public void say() {
        	System.out.println("Hi!");
        }
    	public int getNewAge1() {
    		super.say();
    		show();
    		return  getAge() - 10;
    	}
    	public String getInfo(){//String类是Object 的子类,可以重写
    		return null;
    	}
    	public double Info(){//返回值为基本数据类型时,重写的方法返回值与被重写方法返回值类型一致。
    		return 3.3;
    	}
    	
    	public void readInfo() {
    		System.out.println(super.ID + " " + ID);
    		super.setInfo();
    		System.out.println("舅服你");
    	}
    }
    
    class SubStudent extends Student{
    	public SubStudent() {
    		System.out.println("我是构二代");
    	}
    }
    

    /*

    • java继承性的练习
    • 1,通过Circle与Cylinder类练习继承性与方法的重写
    • 2,创建Account与CheckAccount类综合练习

    */

    package object_chapter2;
    
    public class Extends_Exercise {
    public static void main(String[] args) {
    	Circle c = new Circle(2);
    	System.out.println("半径为" + c.getRadius() + "的圆的面积是:" + c.getArea());
    	Cylinder c1 = new Cylinder(10);
    	c1.setRadius(2);
    	System.out.println("半径为" + c1.getRadius() + "的圆柱的表面积是:" + c1.getArea());
    	System.out.println("半径为" + c1.getRadius() + "高度为" + c1.length + "的圆柱的体积是:" + c1.getVolume());
    	Account a = new Account(1,20000,4.5);
    	a.withdraw(1000);
    	System.out.println("当前账户余额为" + a.getBalance());
    	a.withdraw(21000);
    	System.out.println("当前账户余额为" + a.getBalance());
    	a.withdraw(5000);
    	System.out.println("当前账户余额为" + a.getBalance());
    	CheckAccount ck = new CheckAccount(2,20000,4.4,10000);
    	ck.withdraw(10000);
    	System.out.println("当前账户余额为" + ck.getBalance() + "可透支金额为" + ck.getOverdraft());	
    	ck.withdraw(30000);
    	System.out.println("当前账户余额为" + ck.getBalance() + "可透支金额为" + ck.getOverdraft());		
    	ck.withdraw(15000);
    	System.out.println("当前账户余额为" + ck.getBalance() + "可透支金额为" + ck.getOverdraft());		
    }
    }
    
    class Circle {
    	double radius;
    	
    	public Circle(){
    		super();
    	}
    
    	public Circle(double radius) {
    		super();
    		this.radius = radius;
    	}
    
    	public double getArea() {
    		return Math.PI * radius * radius;
    	}
    
    	public double getRadius() {
    		return radius;
    	}
    
    	public void setRadius(double radius) {
    		this.radius = radius;
    	}
    }
     class Cylinder extends Circle{
    	 double length;
    
    	public Cylinder() {
    		super();
    	}
    
    	public Cylinder(double length) {
    		super();
    		this.length = length;
    	}
    
    	public double getLength() {
    		return length;
    	}
    
    	public void setLength(double length) {
    		this.length = length;
    	}
    	public double getArea() {
    		return 2 * super.getArea() + length * Math.PI * 2 * getRadius();
    	}
    	
    	public double getVolume() {
    		return super.getArea() * length;
    	} 
    }
     class Account{
    	 	private int id;
    		private double balance;
    		private double annualInterestRate;
    		public Account() {
    			super();
    		}
    		public Account(int id, double balance, double annualInterestRate) {
    			super();
    			this.id = id;
    			this.balance = balance;
    			this.annualInterestRate = annualInterestRate;
    		}
    		public int getId() {
    			return id;
    		}
    		public void setId(int id) {
    			this.id = id;
    		}
    		public double getBalance() {
    			return balance;
    		}
    		public void setBalance(double balance) {
    			this.balance = balance;
    		}
    		public double getAnnualInterestRate() {
    			return annualInterestRate;
    		}
    		public void setAnnualInterestRate(double annualInterestRate) {
    			this.annualInterestRate = annualInterestRate;
    		}
    		public void withdraw (double amount) {
    			if(balance >= amount) {
    			balance -= amount;
    			}else {
    				System.out.println("余额不足");
    			}
    		}
    		public void deposit (double amount) {
    			if(amount > 0) {
    			balance += amount;
    			}
    		}
    		
    }
    class CheckAccount extends Account{
    	 private double overdraft;
    	
    	public CheckAccount() {
    		super();
    	}
    	
    	public CheckAccount(int id, double balance, double annualInterestRate,double overdraft) {
    		super(id,balance,annualInterestRate);
    		this.overdraft = overdraft;
    	}
    
    	public double getOverdraft() {
    		return overdraft;
    	}
    
    	public void setOverdraft(double overdraft) {
    		this.overdraft = overdraft;
    	}
    	
    	public void withdraw (double amount) {		
    		if(getBalance() >= amount) {
    		   super.withdraw(amount);
    		}else if(overdraft + getBalance() >= amount){
    			setOverdraft(overdraft + getBalance() - amount);
    			super.withdraw(getBalance());
    		}else {
    			System.out.println("透支超限");
    		}
    	}
     
    }
    
    展开全文
  • 类中具有相同名称的方法可以是声明的方法,继承的方法或两者的组合。重载方法必须具有不同数量的参数,不同类型的参数或两者。方法的返回类型,访问级别和throws子句对使其成为重载方法没有任何影响。参考以下示例...

    在同一类中具有多个具有相同名称的方法称为方法重载。类中具有相同名称的方法可以是声明的方法,继承的方法或两者的组合。

    重载方法必须具有不同数量的参数,不同类型的参数或两者。方法的返回类型,访问级别和throws子句对使其成为重载方法没有任何影响。参考以下示例代码,其中有几个名称为 m1 方法。

    import java.io.IOException;

    class MyClass {

    public void m1(int a) {

    // Code goes here

    }

    public void m1(int a, int b) {

    // Code goes here

    }

    public int m1(String a) {

    // Code goes here

    return 0;

    }

    public int m1(String a, int b) throws IOException {

    // Code goes here

    return 0;

    }

    }

    示例-1

    下面的代码显示了如何使用重载。参考以下代码 -

    public class Main {

    public double add(int a, int b) {

    System.out.println("Inside add(int a, int b)");

    double s = a + b;

    return s;//from ww w. ja v a 2 s . c om

    }

    public double add(double a, double b) {

    System.out.println("Inside add(double a, double b)");

    double s = a + b;

    return s;

    }

    public static void main(String[] args) {

    Main ot = new Main();

    int i = 1;

    int j = 1;

    double d1 = 10.42;

    float f1 = 22.3F;

    float f2 = 24.5F;

    short s1 = 22;

    short s2 = 26;

    ot.add(i, j);

    ot.add(d1, j);

    ot.add(i, s1);

    ot.add(s1, s2);

    ot.add(f1, f2);

    ot.add(f1, s2);

    }

    }

    上面的代码生成以下结果。

    Inside add(int a, int b)

    Inside add(double a, double b)

    Inside add(int a, int b)

    Inside add(int a, int b)

    Inside add(double a, double b)

    Inside add(double a, double b)

    实例-2

    有时,重载方法和自动类型扩展可能会混淆编译器,导致编译器错误。

    class Adder {

    public double add(int a, double b) {

    return a + b;

    }

    public double add(double a, int b) {

    return a + b;

    }

    }

    public class Main {

    public static void main(String[] args) {

    Adder a = new Adder();

    // double d = a.add(2, 3); // A compile-time error

    double d1 = a.add((double) 2, 3); // OK. Will use add(double, int)

    double d2 = a.add(2, (double) 3); // OK. Will use add(int, double)

    }

    }

    ¥ 我要打赏

    纠错/补充

    收藏

    加QQ群啦,易百教程官方技术学习群

    注意:建议每个人选自己的技术方向加群,同一个QQ最多限加 3 个群。

    展开全文
  • 构造方法的特征 它具有与类相同的名称;它不含返回值;注意:在构造方法里不含返回值概念是不同于“void”,在定义构造方法时加了“void”,结果这个方法就不再被自动调了。 构造方法的作用 当一个类实例...
    构造方法

    构造器的定义、作用

    构造方法的特征
    它具有与类相同的名称;它不含返回值;

    注意:在构造方法里不含返回值的概念是不同于“void”的,在定义构造方法时加了“void”,结果这个方法就不再被自动调了。


    构造方法的作用

    当一个类的实例对象刚产生时,这个类的构造方法就会被自动调用,我们可以在这个方法中加入要完成初始化工作的代码。这就好像我们规定每个“人”一出生就必须先洗澡,我们就可以在“人”的构造方法中加入完成“洗澡”的程序代码,于是每个“人”一出生就会自动完成“洗澡”,程序就不必再在每个人刚出生时一个一个地告诉他们要“洗澡”了。

     

    构造器(构造方法)

    功能:创建类的实例时,初始化实例的一组指令。
    语法格式:
      < 修饰符> <类名>([< 参数表>]) {
        [< 语句>]
      }
    举例:
    public class Animal {
      private int legs;
      public Animal() {legs = 4; } //构造器
      public void setLegs(int i) {

        legs = i;

      }
      public int getLegs(){return legs;}
    }
    创建Animal类的实例:Animal a=new Animal(); //调用构造器,将legs初始化为4
    注释:构造器的名称必须与类名相同。修饰符:public、private、protected
    构造器不是方法,没有返回值(连void也不能写)

     

    默认的构造方法

    Java语言中,每个类都至少有一个构造方法;
    如果类的定义者没有显式的定义任何构造方法,系统将自动提供一个默认的构造方法:
    默认构造方法没有参数
    默认构造方法没有方法体
    默认的构造方法:Animal(){}
    所以:不编写构造方法就能用new Xxx()创建类的实例
    Java类中,一旦类的定义者显式定义了一个或多个构造方法,系统将不再提供默认的构造方法;
    构造器的主要作用:利用构造器参数初始化对象的属性

     

    练习3
    1. 在前面定义的Person类中添加构造方法,利用构造方法设置所有人的age属性初始值都为18。
    2. 修改上题中类和构造方法,增加name属性,使得每次创建Person对象的同时初始化对象的age属性值和name属性值。

     1 /**
     2  * 使用 class 关键字定义了一个类: Person
     3  */
     4 public class Person {
     5 
     6     //定义类的属性: 类型 属性名
     7     String name = "unknown";
     8     
     9     //类型 变量名 = 初始值
    10     int age = -1;
    11     
    12     //Java类中,一旦类的定义者显式定义了一个或多个构造方法,系统将不再提供默认的构造方法;
    13     public Person(String personName, int personAge){
    14         System.out.println("洗澡...");
    15         
    16         name = personName;
    17         age = personAge;
    18     }
    19     
    20     //定义类的方法
    21     //带返回值的: 返回值类型 方法名(){ 有可能使用 return 返回具体的值 }
    22     int getAge(){
    23         return age;
    24     }
    25     
    26     //没有返回值的方法: 也开始使用 return 标示方法结束
    27     //return 标示方法结束, return 的后面不能再有其他语句. 
    28     void shout(){
    29         System.out.println("I am " + name);
    30         return;
    31     }
    32     
    33     //带参数, 但没有返回值的方法
    34     void hello(String personName){ 
    35         System.out.println("Hello: " + personName);
    36     }
    37     
    38     //带参数, 且有返回值的方法
    39     int add(int i, int j){
    40         int result = i + j;
    41         return result;
    42     }
    43 }

     

     1 /**
     2  * 测试类
     3  *
     4  */
     5 public class TestPerson {
     6     public static void main(String[] args) {
     7         
     8         //3. 匿名对象: 没有名字的对象. 
     9         new Person("A", 10).shout();
    10         
    11         //2. 创建一个 Person 对象 p2
    12         Person p2 = new Person("B", 18);
    13         p2.shout();
    14         p2.hello("Mike");
    15         
    16         int result2 = p2.add(1, 4);
    17         System.out.println(result2);
    18         int age2 = p2.getAge();
    19         System.out.println(age2); //10. 定义类时的初始值
    20         
    21         //p1 和  p2 是 Person 的两个对象, 操作任何一个的(非静态的)成员变量, 并不会对另一个对象的属性产生影响. 
    22         p2.age = 100;
    23         
    24         System.out.println(); 
    25         
    26         //1. 创建一个 Person 对象 p1
    27         //使用 new 关键字创建一个对象. 
    28         Person p1 = new Person("C", 30);
    29     
    30         //为对象的属性赋值, 使用 . 操作符
    31         p1.age = 30;
    32         p1.name = "Tom";
    33         
    34         //调动对象的方法, 使用 . 操作符
    35         int result = p1.add(2, 5);
    36         System.out.println(result);
    37         
    38         int age = p1.getAge();
    39         System.out.println(age); //30. 在 31 行为 p1 的 age 赋的值
    40         
    41         p1.hello("Jerry");
    42         p1.shout();
    43     }
    44 }

     

    分析对象创建过程内存状态的变化

     

     

    this 关键字

     

    每个成员方法内部,都有一个this引用变量,指向调用这个方法的对象,类中的成员方法与this之间的关系如图:

     

     1 public class Boy {
     2 
     3     private String name;
     4     
     5     public Boy(String n){
     6         name = n;
     7     }
     8     
     9     public String getName() {
    10         return name;
    11     }
    12     
    13     /**
    14      * 和一个女孩进行表白, 并得到女孩的回复. 
    15      * @param girl
    16      */
    17     public void marry(Girl girl){
    18         System.out.println("嫁给我吧: " + girl.getName()); 
    19         
    20         /**
    21          * this: this 是对 "调用当前方法的那个-当前对象" 对象的引用. 
    22          * 当前对象: 当前方法所在的对象. 
    23          * 
    24          * this 的用途: 指代的是当前对象
    25          * 1. 在一般的方法中可以通过 this 来引用当前对象的成员(方法、属性)
    26          * 2. 通过 this() 调用重载的构造器. 需要注意的是, 通过此种方法调用重载的构造器的代码必须放在当前构造器的第一行. 
    27          * 
    28          * public Person(String n, int a, String s, String m){
    29          *        this(n, a, s);
    30          *        major = m;
    31          *    }
    32          * 
    33          */
    34         girl.shout(this);
    35     }
    36 }
     1 public class Girl {
     2 
     3     private String name;
     4     
     5     public Girl(String n){
     6         name = n;
     7     }
     8     
     9     public String getName() {
    10         return name;
    11     }
    12     
    13     public void shout(Boy boy){ 
    14         System.out.println("好吧, 嫁给你: " + boy.getName());
    15     }
    16 }
    1 public class TestThis {
    2     public static void main(String[] args) {
    3         
    4         Boy boy = new Boy("Tom");
    5         Girl girl = new Girl("Jerry");
    6         
    7         boy.marry(girl);
    8     }
    9 }

     

    函数的参数传递


    基本数据类型的参数传递

     

     1 //package: package语句作为Java源文件的第一条语句,指明该文件中定义的类所在的包
     2 package com.atguigu.app;
     3 
     4 //import:为使用定义在不同包中的Java类,需用import语句来引入所需要的类。
     5 //import语句告诉编译器到哪里去寻找类。
     6 import java.io.File;
     7 import java.text.DateFormat;
     8 
     9 class PassValue{
    10     public static void main(String [] args){
    11         
    12         File file = null;
    13         System.out.print(Math.PI);
    14         
    15         int x = 5;
    16         change(x);
    17         System.out.println(x);
    18     }
    19     
    20     public static void change(int y){
    21         y = 3;
    22     }
    23 }

     


    引用数据类型的参数传递

     

     1 public class PassRef {
     2     int x;
     3     public static void main(String [] args) {
     4         PassRef obj = new PassRef();
     5         obj.x = 5;
     6         change(obj);
     7         System.out.println(obj.x);
     8     }
     9 
    10     public static void change(PassRef obj) {
    11         obj.x = 3;
    12     }
    13 }

     

     

     

     

     1 public class PassRef1 {
     2 
     3     int x;
     4     public static void main(String [] args){
     5         PassRef obj = new PassRef();
     6         obj.x = 5;
     7         change(obj);
     8         System.out.println(obj.x);
     9     }
    10     
    11     public static void change(PassRef obj){
    12         obj = new PassRef();
    13         obj.x = 3;
    14     }
    15 }

     

     

    package语句/import语句


    package语句作为Java源文件的第一条语句,指明该文件中定义的类所在的包。(若缺省该语句,则指定为无名包)。它的格式为:
      package <顶层包名>[.<子包名>]* ;
    举例:pack\Test.java
      package p1; //指定类Test属于包p1
      public class Test {
        public void display() {
        System.out.println("in method display()");
      }
    }

    包对应于文件系统的目录,package语句中,用‘ .’ 来指明包(目录)的层次;
    包通常用小写单词,类名首字母通常大写
    为使用定义在不同包中的Java类,需用import语句来引入所需要的类。Import语句告诉编译器到哪里去寻找类。

    语法格式:
      import 包名[.子包名…]. <类名 |*>
    应用举例:
      import p1.Test; //import p1.*;表示引入p1包中的所有类
      public class TestPackage{
        public static void main(String args[]){
        Test t = new Test(); //Test类在p1包中定义
        t.display();
      }  
    }

    JDK中主要的包介绍


    java.lang----包含一些Java语言的核心类,如String、Math、Integer、System和Thread,提供常用功能。
    java.net----包含执行与网络相关的操作的类。
    java.io----包含能提供多种输入/输出功能的类。
    java.util----包含一些实用工具类,如定义系统特性、使用与日期日历相关的函数。

    展开全文
  • 觉得文章不错的读者可以关注一下作者的博客和公众号(同博客名称)二 方法重载2.1 方法重载的定义方法重载是指同名的方法具有不同的参数列表;不同的参数列表是指参数列表个数不同或者相同的个数的参数,但具有不同的...

    一 前言

    本节内容将会提到方法重载,对象的初始化,对象的构造器,和this关键字的使用,以及会简要的概括一下java中对象回收机制。觉得文章不错的读者可以关注一下作者的博客和公众号(同博客名称)

    二 方法重载

    2.1 方法重载的定义

    方法重载是指同名的方法具有不同的参数列表;不同的参数列表是指参数列表个数不同或者相同的个数的参数,但具有不同的参数类型;

    代码示例:

    /**

    * @Author lsc

    *

    方法重载

    */

    public class OverLoadZ {

    public static void main(String[] args) {

    // 创建对象

    OverLoadZ overLoadZ = new OverLoadZ();

    // 最初的方法

    String keepWarm1 = overLoadZ.keepWarm();

    System.out.println(keepWarm1);

    // 多一个参数列表方法重载

    String keepWarm2 = overLoadZ.keepWarm("穿上大棉袄");

    System.out.println(keepWarm2);

    // 相同个数参数,不同参数类型重载

    String keepWarm3 = overLoadZ.keepWarm(2);

    System.out.println(keepWarm3);

    // 多个参数重载

    String keepWarm4 = overLoadZ.keepWarm("穿上大棉袄",2);

    System.out.println(keepWarm4);

    }

    // 最初的方法

    private String keepWarm(){

    return "开启暖气";

    }

    // 多一个参数列表方法重载

    private String keepWarm(String action){

    return action;

    }

    // 相同个数参数,不同参数类型重载

    private String keepWarm(Integer number){

    return "穿上大棉袄"+number+"件";

    }

    // 多个参数重载

    private String keepWarm (String action,Integer number){

    return action+number+"件";

    }

    }

    输出:

    开启暖气

    穿上大棉袄

    穿上大棉袄2件

    穿上大棉袄2件

    2.2 返回值类型不同为什么不是方法重载

    public string keepWarm() 方法 和 public Integer keepWarm() 方法,当我们调用这连个方法时不需要将返回值赋值给另外变量情况下 那么都是 keepWarm() 这样调用,这样就无法区分我们到底是调用了那个方法,故方法重载不能使用返回值类型作为判断依据;

    三 构造器

    3.1 对象的初始化

    如果每个对象都有一个初始化方法,也就是类似变量赋初值,那么类构造器就是对象的初始化方法;对象的构造器的命名规则同类名一致;当我们没有定义类的构造器时,编译器默认会帮我们创建一个空参的构造器;如果我们自定义了构造器,编译器则不会再次帮我们创建空参构造器;如此看来构造器也就是一个特殊的方法,其有参数列表,但没有返回值;

    如何声明对象,创建对象,看代码示例,我们不想马上实例化一个对象可以对这个对象赋值为null;当需要使用到这个对象的时候再具体实例化,如果没有实例化对象,而使用了对象的成员,会报空指针异常;

    /**

    * @Author lsc

    *

    知识追寻者 对象初始化系列

    */

    public class Build {

    public static void main(String[] args) {

    // 声明一个对象赋值为NULL

    Build build = null;

    // 如果对象为空就创建对象

    if (build==null){

    new Build();

    }

    build.hobby();

    }

    private void hobby(){

    System.out.println("知识追寻者爱吃大西瓜");

    }

    }

    3.2 默认构造器

    默认构造器也就是空参构造器;如下代码中我们没有自定义构造器,我们也能创建一个空参的对象build,然后调用build对象的 hobby()方法

    /**

    * @Author lsc

    *

    知识追寻者 对象初始化系列

    */

    public class Build {

    public static void main(String[] args) {

    Build build = new Build();

    build.hobby(); // 输出 知识追寻者爱吃大西瓜

    }

    private void hobby(){

    System.out.println("知识追寻者爱吃大西瓜");

    }

    }

    自定义空参构造器示例如下,可以看见结果和编译器默认创建的空参构造器执行结果一致;

    public class Build {

    Build(){

    // 空参构造器,

    }

    public static void main(String[] args) {

    Build build = new Build();

    build.hobby();// 输出 知识追寻者爱吃大西瓜

    }

    private void hobby(){

    System.out.println("知识追寻者爱吃大西瓜");

    }

    }

    为空参构造器赋初值示例如下,可以看见先打印了构造器中的内容,然后再打印hobby方法内容;所有对象在初始化得到时候执行的是构造器方法,构造器方法中的内容也会着对象的创建而执行;

    /**

    * @Author lsc

    *

    知识追寻者 对象初始化系列

    */

    public class Build {

    Build(){

    System.out.println("知识追寻者爱看书");

    }

    public static void main(String[] args) {

    Build build = new Build();

    build.hobby();

    }

    private void hobby(){

    System.out.println("知识追寻者爱吃大西瓜");

    }

    }

    输出:

    知识追寻者爱看书

    知识追寻者爱吃大西瓜

    3.3 重载构造器

    学了方法重载,构造器重载也随之很简单,也就是构造器也有参数列表,根据不同的参数列表创建的构造器,我们创建的对象也随之不同;

    /**

    * @Author lsc

    *

    知识追寻者 重载构造器

    */

    public class OverLoadBulid {

    // 知识追寻者的爱好1

    private String hobby1;

    // 知识追寻者的爱好2

    private String hobby2;

    // 空参构造器

    OverLoadBulid(){

    }

    // 重载构造器1

    OverLoadBulid(String hobby1){

    // 创建对象的时候会执行构造器方法

    System.out.println(hobby1);

    }

    // 重载构造器1

    OverLoadBulid(String hobby1, String hobby2){

    // 创建对象的时候会执行构造器方法

    System.out.println(hobby1);

    System.out.println(hobby2);

    }

    public static void main(String[] args) {

    // 打印 知识追寻者爱看书

    OverLoadBulid loadBulid1 = new OverLoadBulid("知识追寻者爱看书");

    // 打印 知识追寻者爱看书 知识追寻者爱写作

    OverLoadBulid loadBulid2 = new OverLoadBulid("知识追寻者爱看书","知识追寻者爱写作");

    }

    }

    四 this关键字

    4.1 this关键字介绍

    官方指的this关键字定义如下:在实例的方法或者构造器中,this关键字保存的是当前对象的引用,可以通过this关键字调用当前对象的任何成员;

    4.2 this关键字的使用场景

    用在字段上;

    用在构造器上;

    用在实例方法上;

    /**

    * @Author lsc

    *

    知识追寻者 this 关键字

    */

    public class ObjectZ {

    private String hobby1;

    private String hobby2;

    ObjectZ(String hobby1, String hobby2){

    // this 使用在字段上

    this.hobby1 = hobby1;

    this.hobby2 = hobby2;

    }

    // this 用在 构造器上

    ObjectZ(){

    // 这边会调用构造器 ObjectZ(String hobby1, String hobby2)

    this("知识追寻者爱看书", "知识追寻者爱写作");

    }

    // this 用在方法上

    public ObjectZ action(){

    // 返回对象实例

    return this;

    }

    public static void main(String[] args) {

    ObjectZ objectZ = new ObjectZ();

    ObjectZ action = objectZ.action();

    // this指向的是对象的引用,此时表示同一个对象,this 就是 objectZ实例

    System.out.println(objectZ==action);//true

    // 成员以已经被赋初值

    System.out.println(action.hobby1);// 知识追寻者爱看书

    }

    }

    五 垃圾回收简介

    Java中的对象回收是通过垃圾回收机制(Garbage Collection)进行对象的回收,在垃圾回收(System.gc()方法)之前会调用对象的 finalize()方法,判断该对象是否可回收; 如果 finalize()(在gc之前java虚拟器会自动调用该方法,并且jvm只执行一次该方法)被jvm执行过,就会进行对象回收,释放空间;如果在垃圾回收之前我们手动执行了 finalize() 方法,并且又对对象进行赋值,就会造成对象逃逸,gc并没有成功,原因是 finalize()方法已经被执行了;finalize()的用途一般用在在对象回收之前关闭一些资源,不过通常我们也不会这么做,后续的学习中会有更优方案, 而且调用 finalize() 方法在java中是异常危险的举动,建议读者忘记这个方法,所以笔者这边不会给出具体示例;

    展开全文
  • 当对父类的方法进行重写时,子类中的方法必须和父类中对应的方法具有相同的方法名称,在PHP5中不限制输入参数类型、参数数量和返回值类型。(这点和Java不同)。子类中的覆盖方法不能使用比父类中被覆盖方法更严格的...
  • 当对父类的方法进行重写时,子类中的方法必须和父类中对应的方法具有相同的方法名称,在PHP5中不限制输入参数类型、参数数量和返回值类型。(这点和Java不同)。子类中的覆盖方法不能使用比父类中被覆盖方法更严格的...
  • 重载是实现多态的机制之一,其中一个类包含两个具有相同名称不同参数的方法。无论何时调用此方法,方法主体都将基于参数与方法调用绑定。示例在下面的Java程序中,Calculator类有两个带有名称加法的方法,唯一的...
  • 事实上,多态最直接的定义是让具有继承关系的不同对象可以相同名称的成员函数调用,产生不同反应效果。所谓多态性就是指一段程序能够处理多种类型对象的能力,在PHP中,多态值指的就是方法的重写。方法重写是...
  • 当对父类的方法进行重写时,子类中的方法必须和父类中对应的方法具有相同的方法名称,在PHP5中不限制输入参数类型、参数数量和返回值类型。(这点和Java不同)。 子类中的覆盖方法不能使用比父类中被覆盖方法更严格...
  • 最直接的定义解释让具有继承关系的不同类对象可以相同名称的成员函数调用,产生不同的反应效果 多态性值得就是方法的重写。方法的重写是指一个子类中可以重新修改父类中的某些方法。使其具有自己的特征。 ...
  • 觉得文章不错的读者可以关注一下作者的博客和公众号(同博客名称)二 方法重载2.1 方法重载的定义方法重载是指同名的方法具有不同的参数列表;不同的参数列表是指参数列表个数不同或者相同的个数的参数,但具有不同...
  • 事实上,多态最直接的定义是让具有继承关系的不同对象可以相同名称的成员函数调用,产生不同反应效果。所谓多态性就是指一段程序能够处理多种类型对象的能力,在PHP中,多态值指的就是方法的重写。方法重写是...
  • (1),C#构造函数是在创建给定类型的对象时执行的类方法。 (2),构造函数没有返回值(void也不需要) (3),如果一个类中可以有多个构造函数 ,可根据其参数个数的不同或参数类型的不同来区分它们,这称作构造函数的重载 (4...
  • 所谓的“多态”,简单的理解就是对象在不同情况下的不同表现,...方法重载的概念比较好理解,简单的说,就是在同一个类中,定义了多个方法,具有相同的方法名称不同的参数列表。方法重载只看名称和参数列表,其...
  • 不,在覆盖超类的方法时,我们需要确保两个方法都具有相同名称,相同的参数和相同的返回类型,否则它们将被视为不同的方法。简而言之,如果我们更改签名,则尝试执行超类的方法时,将无法覆盖超类的方法。原因-...
  • 命名空间(在PHP V5.3中引入)是一种提供PHP类,常量和函数上下文的方法,以便具有相同名称的元素可以理解为唯一。 唯一的名称使您避免命名冲突,当存在两个相同名称的类或函数时,会发生命名冲突。 有时,这些PHP类...
  •  在 eat 与 sleep 方法中都是 String 类型的 name, 说明不同的方法可以有同名的局部变量  当成员变量与局部变量名称相同时,局部变量更具有优先级  使用 this. 属性,代表成员变量  成员变量有默认 , 引用...
  • Java中的重载是能够在类中定义多个具有相同名称的方法。由于方法签名,编译器能够区分这些方法。这一术语也可以称为方法重载,主要用于增加程序的可读性;让它看起来更好看。但是,如果做得太多,可能会产生相反的...
  • python面向对象基础

    2018-11-05 19:53:45
    Python类提供了面向对象编程的所有标准功能:类继承机制允许多个基类,派生类可以重写其基类或类的任何方法,并且方法可以调用具有相同名称的基类的方法对象可以包含任意数量和种类的数据。...
  • 面向对象

    2018-05-09 21:23:27
    一、什么是类具有相同方法和属性一组对象的集合二、什么是对象用来描述客观事物一个实体,由一组属性和方法构成三、方法和属性是什么属性:对象具有特征方法对象执行操作四、什么是方法重载(附码)重载,...
  • 面向对象编程-源码

    2021-02-11 10:06:03
    面向对象编程是一种编写代码的方法,该代码使您可以从一个公共对象创建不同的对象。 公共对象通常称为蓝图,而创建的对象称为实例。 每个实例具有不与其他实例共享的属性。 例如,如果您具有人工蓝图,则可以创建...
  • 每一个使用new操作符实例化的对象和函数对象都包含一个<strong>proto属性,它是构造函数“prototype”属性的引用,先看一段代码: <pre><code> function Foo() {} var foo = new Foo(); alert...
  • 具有与类相同的名称; 它不含返回值;在构造方法里不含返回值概念是不同于 “void” ,在定义构造方法时加了 “void” ,结果这个方法就不再被自动调用了。 它不能在方法中用 return 语句返回一个值; 当...
  • 具有与类相同的名称 它不声明返回值类型(与声明为void不同) 不能被static、final、synchronized、abstract、native修饰,不能有 return语句返回值 二、构造器作用 创建对象对象进行初始化 如:Order o ...
  • 构造函数如果没有被显式的...构造方法只会在对象创建的时候被调用一次,调用完成后即出栈,而一般的方法可以对象创建后调用多次;构造方法中,默认也是有return语句的,任何方法都是有return语句的,如果不显式的写

空空如也

空空如也

1 2 3 4 5 ... 16
收藏数 306
精华内容 122
关键字:

不同的对象可以具有相同名称的方法