精华内容
下载资源
问答
  • JAVA 重写父类方法

    2020-10-29 21:28:16
    二、怎样重写父类方法? 只有方法体不同,其他都相同 三、重写父类方法的合法范例 “快来吃饭了!”和“猫吃鱼” package cn.whsw.jsjx; public class Animal { public void eat(){ System.out.println("快来...

    一、为什么要重写父类方法?

    方法的重写发生在子父类的关系中,当父类提供的功能不满足子类的需求时,子类可以对父类进行重写。

    二、怎样重写父类方法?

    只有方法体不同,其他都相同

    三、重写父类方法的合法范例

    “快来吃饭了!”和“猫吃鱼”

    
    public class Animal {
    	public void eat(){
    		System.out.println("快来吃饭了!");
    	}
    }
    -----------------------------------------------------------------------------
    
    public class Cat extends Animal {
    	@Override //强制检查该方法是不是重写的方法,避免(名称)出错
    	public void eat(){
    		System.out.println("猫吃鱼");
    	}
    
    }
    -----------------------------------------------------------------------------
    public class Testcat2 {
    	public static void main(String[] args){
    		Cat c=new Cat();
    		c.eat();		
    	}
    
    }
    

    结果:
    猫吃鱼

    注意:@Override 可以强制检查重写方法

    展开全文
  • 那么问题来了,如果在子类中利用super关键字调用父类的同名方法时,会怎样? 代码如下: 这里我自定义了两个异常,它们为父子类关系。 定义了两个实体类,它们为父子关系。 package com.calarqiang.exception; ...

    总所周知,在Java异常机制中,如果父类的一个方法抛出了异常,那么当有子类继承自这个父类时,如果重写了这个方法,那么它抛出的异常范围有三种情况:
    情况一: 和父类异常一致
    情况二:比父类异常范围小(即为父类异常的子类)
    情况三:不抛出任何异常

    针对情况二:

    那么问题来了,如果在子类中利用super关键字调用父类的同名方法时,会怎样?

    代码如下:
    这里我自定义了两个异常,它们为父子类关系。
    定义了两个实体类,它们为父子关系。

    package com.calarqiang.exception;
    
    import java.io.IOException;
    
    /**
     * @author yq
     * @create 2021-01-27-19:30
     */
     
     //自定义异常父类
    public class MyException extends IOException {
      public MyException(){
    
      }
      public MyException(String message){
          super(message);
      }
    }
    
    //自定义异常子类,继承自异常父类
    class SonException extends MyException{
        public SonException(){}
        public SonException(String message){
            super(message);
        }
    }
    
    //实体父类,Person
    class Person{
        public void run ()throws MyException {
            throw new MyException("父类抛出异常!");
        }
    }
    
    //实体子类,继承自实体父类Person
    class Son extends Person{
        public void run() throws SonException{
        //问题就在这,这里必须进行处理,不能不处理,因为父类异常大于子类异常
        //而子类抛出的异常声明比父类的小,它不包含父类异常,因此必须进行try-catch处理!!!
            try {
                super.run(); 
            } catch (MyException e) {
                System.out.println(e);
            }
            throw new SonException("子类抛出异常!!");
        }
    }
    
     class Test{
        public static void main(String[] args) {
            Son son = new Son();
            try {
                son.run();
            } catch (SonException e) {
                System.out.println(e);
            }
        }
    }
    

    如上所述:由于子类抛出的异常范围必须小于或者等于父类的异常范围,而如果子类的重写方法调用父类的重写方法时,这时父类要抛出异常,而子类抛出的异常声明又小于父类的异常,因此无法处理父类的异常,所以必须在子类方法中就用try-catch处理父类的异常。

    其它几种情况:

    而针对情况一来说,就可以不用处理了,直接在调用子类方法处一起处理子父类异常。
    针对情况三来说,由于子类不能抛异常,那么调用父类就必须在方法体内部处理异常,同时自身如果抛出异常的话,也必须处理!

    那么为什么父类的就要比子类大呢?

    不能非黑即白!因为可以这样想:
    如果一个父类对象作为一个类中的方法参数,当调用该类的方法时,抛出异常,此时在方法体内处理它,但是如果传递的是一个子类对象进去(多态),那么当此时子类的异常比父类大,那么方法内部的try-catch就无法处理捕获它,从而发生错误。因此就要比父类异常小!


    这里有另外一个知识点:
    关于检查性型异常和非检查型异常

    • 检查型异常
      其它的异常则称为检查型异常。
    • 非检查型异常
      所有的派生于Error类或者RuntimeException类的异常称为非检查型异常。

    对于检查型异常,要么在方法内部处理掉,要么声明(throws)一个方法内部可能出现的所有检查型异常。
    如果调用了一个抛出检查型异常的方法

    1. 就必须处理这个异常
    2. 继续传播这个异常。
      具体做法就是捕获知道如何处理的异常,而继续传播哪些不知道怎么处理的异常!

    避免声明非检查型异常,因为它完全可以由编程者仔细检查避免!

    展开全文
  • 调用被子类重写方法

    千次阅读 2016-12-16 16:58:44
    访问权限允许的情况下,子类可以调用父类方法,这是因为子类继承父类会获得父类定义的成员变量和方法;但父类不能调用子类的方法,因为父类根本无从知道它将被哪个子类继承,它的子类将会增加怎样的方法. 但有一种特殊...

    在访问权限允许的情况下,子类可以调用父类方法,这是因为子类继承父类会获得父类定义的成员变量和方法;但父类不能调用子类的方法,因为父类根本无从知道它将被哪个子类继承,它的子类将会增加怎样的方法.

    但有一种特殊情况,当子类方法重写了父类方法后,父类表面上只是调用属于自己的,被子类重写的方法,但随着执行context的改变,将会变成父类实际调用子类的方法.

    下面程序中定义了两个具有父子关系的类Animal和Wolf,其中Wolf重写了Animal的getDesc()方法.

    package com.lic.array;
    
    public class Demo15 {
    	public static void main(String[] args) {
    		System.out.println(new Wolf_15("灰太狼",32.3)); // 1
    	}
    }
    class Animal_15{
    	// desc 实例变量保存对象toString 方法的返回值
    	private String desc;
    	public Animal_15(){
    		// 调用getDdesc()方法初始化desc实例变量
    		this.desc = getDesc();  // 2
    	}
    	public String getDesc(){
    		return "Animal";
    	}
    	public String toString(){
    		return desc;
    	}
    }
    class Wolf_15 extends Animal_15{
    	// 定义name, weight两个实例变量
    	private String name;
    	private double weight;
    	public Wolf_15(String name, double weight){
    		// 为name,weight两个实例变量赋值
    		this.name = name;   // 3
    		this.weight = weight;
    	}
    	// 重写父类的getDesc()方法
    	@Override
    	public String getDesc(){
    		return "Wolf_15[name="+name+", weight="+weight+"]";
    	}
    }
    上面程序中,Animal类的2行代码将desc实例变量的值赋为getDesc()方法的返回值,Animal的Wolf子类重写了Animal类的getDesc()方法.其中Animal的getDesc()方法只是一个返回"Animal"字符串,但Wolf的getDesc()方法则返回形如Wolf[name=value, weight=value]的字符串.

    程序在1行代码处创建一个Wolf对象,并为Wolf对象的name实例变量,weight实例变量指定值.运行该程序,输出结果是什么呢?Wolf[name=灰太狼,weight=32.3]?世纪运行改程序,会发现输出Wolf_15[name=null, weight=0.0],那么为name,weight实例变量指定的值呢?

    理解这个程序的关键在于2行代码,表面上此处是调用父类中定义的getDesc()方法,但实际运行过程中,此处会变为调用被子类重写的getDesc()方法.

    程序从1行代码处开始执行,也就是调用Wolf类对应的构造器来初始化该Wolf对象.但在执行Wolf构造器里的代码(即3行代码)之前,系统会隐式执行其父类无参数的构造器,也就是说,程序在执行3行代码之前会先执行2行代码.执行2行代码时,不再是调用父类的getDesc()方法,而是调用Wolf类的getDesc()方法.此时,程序还没有执行3行代码,因此Wolf的name,weight实例变量将保持默认值----name的值为null,weight的值为0.0;

    因此Wolf的getDesc()方法返回值是Wolf[name=null, weight=0.0], 于是desc实例变量将赋为Wolf[name=null, weight=0.0],这就是看到的输出结果.

    当执行完2行代码的赋值语句之后,程序会对Wolf对象的name,weight两个实例变量进行赋值,也就是说,最终得到Wolf对象的name实例变量的值是灰太狼,weight实例变量的值是32.3,只是它的desc实例变量的值是Wolf[name=null, weight=0.0].

    通过上面分析可以看到,该程序产生这种输出的原因在于,2行代码处调用的getDesc()方法是被子类重写过的方法.这样使得对Wolf对象的实例变量赋值的语句 this.name = name;,this.weight = weight; 在getDesc()方法之后被执行,因此getDesc()方法不能得到Wolf对象的name,weight实例变量的值.

    为了避免这种不希望看到的结果,应该避免在Animal类的构造器中调用被子类重写过的方法,因此将类改写为如下形式即可:

    class Animal_15_1{
    	// desc 实例变量保存对象toString 方法的返回值
    	private String desc;
    	public String getDesc(){
    		return "Animal";
    	}
    	public String toString(){
    		return getDesc();
    	}
    }
    经过改写的Animal_15_1类不再提供构造器(系统会为之提供一个无参数的构造器),程序改由toString()方法来调用被重写的getDesc()方法.这就保证了对Wolf对象的实例变量赋值的语句this.name = name;, this.weight = weight; 在getDesc()方法之前被执行,从而使得getDesc()方法得到 Wolf对象的name,weight实例变量的值.

    如果父类构造器调用了被子类重写的方法,且通过子类构造器来创建子类对象,调用(不管是显式还是隐式)了这个父类构造器,就会导致子类的重写方法在子类构造器的所有代码之前被执行,从而导致子类的重写方法访问不到子类的实例变量的值的情形.

    展开全文
  • 父类中private的成员方法在子类中无法重写怎样理解哦~
  • 在子类继承父类后,在调用子类的功能后后发现子类的功能不满足我们的需求时,我们就要在子类中重新编写相同的方法,达到覆盖父类中该方法的效果,这样再次调用就能满足我们的需求了。其实就是对于子类的一些行为的...

    java基础学习08(重写方法、jdk自带的Object类、封装)

    第一章 接上次讲继承中的方法重写

    在子类继承父类后,在调用子类的功能后后发现子类的功能不满足我们的需求时,我们就要在子类中重新编写相同的方法,达到覆盖父类中该方法的效果,这样再次调用就能满足我们的需求了。其实就是对于子类的一些行为的扩展。

    出现方法重写的前提:一定发生继承关系!!

    1.1 怎样达到子类方法覆盖父类方法?

    • 子类中方法名和父类中方法名一模一样;
    • 子类中方法的参数列表和父类方法中的参数列表一模一样;
    • 子类中方法返回值类型也好和父类方法返回值也要一模一样。

    实例代码:

    public class Father {
    	String name;
    	int age;
    	int height;
    	public Father(){
    	}
    	public int getAge(){
    		this.age = 45;
    		return this.age;
    	}
    }
    public class Son extends Father{
    	int id;
    	public Son(){
    	}
        @Override
    	public int getAge(){
    		this.age = 20;
    		return this.age;
    	}
    }
    public class Text {
    	public static void main(String[] args) {
    		Son t = new Son();
    		System.out.println(t.getAge());
            //输出结果是20
    	}
    }
    

    代码分析:在上述代码中,Son类继承了Father类,所以Son类是子类,Father是父类,我们发现子类和父类中都存在getAge方法,且两个类中该方法参数列表都是空,返回值也是一样的,所以在子类中我们重写了getAge方法,这样的就不会调用父类的getAge方法了,所以输出结果是20。

    @Override:我们在子类重写的那个方法上面一行(上述代码所示)写上@Override,如果会报错,那么说明该方法不是重写方法,这也是判断该方法是不是重写方法的一种方法。

    **tips:**子类对象调用子类的方法和属性是,现在子类中找,如果子类中没有,那么就会去父类中找,会沿着继承链一直往上找。

    1.2 所有类的默认存在的父类Object

    1.2.1 什么是Object类?

    Object类是JDK中存在的一个默认类,是所有类的直接父类或者间接父。在Object中存在的方法所有类中都具备。

    1.2.2 Object类中的重要方法(暂只讲两个)

    1、toString();

    Object类中的toString方法:

    public String toString() {    
        return getClass().getName() + "@" + Integer.toHexString(hashCode()); 
    }
    

    示例代码:

    public class Text01 {
    	int num = 10;
    	public static void main(String[] args) {
    		Text01 t = new Text01();
    		System.out.println(t);
    	}
    }//输出结果com.mage.methodRewrite.Text01@15db9742
    

    代码分析:我们在打印一个对象的时候,其实默认调用的就是该对象的toString方法,该类的对象如果该类中不存在toString方法,那么就会去该类默认的父类Object类中寻找,从而输出的是上述代码简称为包名.类名@16进制的值(地址值)。

    那么如果我们不要输出这样的结果,我们就要去当前类中改写toString方法,那我们看下面的实例代码:

    public class Text02 {
    	int age;
    	String name;
    	public Text02(){	
    	}
    	public static void main(String[] args) {
    		Text02 t = new Text02();
    		System.out.println(t);
            //输出结果是张三	30
    	}
    	public String toString(){
    		this.name = "张三";
    		this.age = 30;
    		return (this.name+"\t"+age);		
    	}
    }
    

    分析上述代码:我们说打印一个对象就是调用该对象的toString方法即输出该对象的地址值,那么我们在本类中改写toString方法,这样调用的toString方法就是本类中的了,而不会去调用该类默认父类的toString方法了。这样结果就是上述代码中的了。

    2、equals();

    比较两个对象是否相等。

    Object中的equals方法代码:

    public boolean equals(Object obj) {    
    	return (this == obj); 
    }
    

    示例代码:

    public class Text03 {
    	int num = 10;
    	public static void main(String[] args) {
    		Text03 t = new Text03();
    		Text03 t1 = new Text03();
    		System.out.println(t);
            //输出结果是com.mage.methodRewrite.Text03@15db9742
    		System.out.println(t1);
            //输出结果是com.mage.methodRewrite.Text03@6d06d69c
    		System.out.println(t.equals(t1));
            //输出结果是false
    	}
    }
    

    **总结:**对象的比较就是比较其地址值,而每次new出来都会在堆内存开出新的内存,也就意味着对象的不同那么地址值也是不一样的,所以去比较两个不同的对象是结果一定是false。

    **tips:**基本对象的比较就是比较变量值,而我们的String类型属于引用数据类型,它比较的是地址值。

    又是我们比较对象可以去看对象的属性功能是不是相等,这个时候我们说对象的属性和功能相等我们就输出ture,不相等我们就输出false。那么我们就要去对象类中改写equals方法达到这种效果。看如下示例代码:

    public class Person {
    	String name;
    	int age;
    	char gender;
    	public Person(){	
    	}
    	public boolean equals(Object obj){
    		Person other = (Person)obj;
    		if(this.name.equals(other.name)&&this.age==other.age){
    			return true;
    		}
    		return false;
    	}
    }
    public class PersonText {
    	public static void main(String[] args) {
    		Person t = new Person();
    		t.name = "德玛西亚之力";
    		t.age = 18;
    		Person t1 = new Person();
    		t1.name = "德玛西亚之力";
    		t1.age = 18;
    		boolean flag = t.equals(t1);
    		System.out.println(flag);
            //输出结果是ture
    	}
    }
    

    代码分析:在上述代码中调用了JDK中默认存在的String类,如果equals比较的是String类型的时候,会比较字符串中的每一个元素,全部相等即为相等。

    那么又有下引申:我们要去比较随意字符串和对象是否相等?想法:我们这里要使用if判定语句,如果该字符串是类的属性,且字符串相等那么两个才会相等,该字符串如果都不是类的属性,那么都不用比较就知道肯定不会相等了,这里就要用到比较引用属性的运算符了:instanceof。看下面实例代码:

    public class Animals {
    	String name;
    	int age;
    	int weight;
    	public Animals(){	
    	}
    	public boolean equals(Object obj){
    		if(!(obj instanceof Animals)){
    			return false;
    		}
    		Animals other = (Animals) obj;
    		if(this.name.equals(other.name)&&this.age==other.age){
    			return true;
    		}
    		return false;
    	}
    }
    public class AnimalsText {
    	public static void main(String[] args) {
    		Animals t = new Animals();
    		t.name = "狐狸";
    		t.age = 6;
    		String strs = "老虎";
    		boolean flag = t.equals(strs);
    		System.out.println(flag);
    	}
    }
    

    **代码分析和结论:**这个代码比较的是数组和对象,但是我们可以想到一个类的对象和一个不属于这个类的数组去比较得出的值就是false;上述代码体现的是Object中变量obj可以传入任意的值,所以我们在Animals类中改写的equals方法中加入了新的代码即if语句,如果传入的值都不属于该类,那么就不用做后续操作,直接输出false即可。不论这里strs的值是不是和this.name的值一不一样,都会输出false,就是因为strs中的值不是属于Animals这个类的。

    下面我们再来测试其他的结果:

    public class Animals {
    	String name;
    	int age;
    	int weight;
    	public Animals(){	
    	}
    	public boolean equals(Object obj){
    		if(!(obj instanceof Animals)){
    			return false;
    		}
    		Animals other = (Animals) obj;
    		if(this.name.equals(other.name)&&this.age==other.age){
    			return true;
    		}
    		return false;
    	}
    }
    public class AnimalsText {
    	public static void main(String[] args) {
    		Animals t = new Animals();
    		t.name = "狐狸";
    		t.age = 6;
    		//当String strs赋值为null时会不会报错(不会报错)
    		String strs = null;
    		boolean flag = t.equals(strs);
    		System.out.println(flag);
    		//一个给属性赋值的对象t和一个没有给属性赋值的对象t1做比较(不会报错)
    		Animals t1 = new Animals();
    		System.out.println(t.equals(t1));
    		//一个直接赋值为null的对象和给属性赋值的对象做比较(不会报错)
    		Animals t2 = new Animals();
    		System.out.println(t.equals(t2));
    	}
    }
    

    总结:

    • 注意调用equals方法的对象值一定不能为null,否则会出现空指针异常,而equals方法中的形式参数可以是null值,这样不会报错,输出值为false;
    • 在给equals方法带入实参null时,输出值为false,原因是null不属于任何的引用类型。但是引用数据类型可以赋值null。

    1.3 类型转换

    引用数据类型转换和基本数据类型基本相似。

    1、自动转换

    表现形式为:大类型 变量名 = 小类型值

    实例代码:

    class F{ }
    class S extends F{  
    	S s = new S(); 
    	System.out.println(s);
    	F f = s; 
    	System.out.println(f);
    }
    

    2、强制转换

    小类型 变量名 = (小类型)大类型值;

    子类型 变量名 = (子类型)父类型变量;

    实例代码:

    S s1 = (S)f;
    System.out.println(s1); 
    F f1 = new F(); 
    S s2 = (S)f1;
    

    注意事项:引用类型的强制转换要格外的小心,基本不要使用,你一定要知道当前变量的实际类型是什么才能强转,例如我们将一个子类A赋值给父类,而后我们强转将父类赋值给另外一个子类B,这个时候就会报错,这里不能肯定子类A和子类B会相等。

    第二章 封装

    2.1 什么是封装?

    封装就是我们通过一些修饰的关系词来降低类,构造器、属性,功能的可见率来控制其他类对这些类,构造器、属性和功能的访问。

    2.2 如何去封装?

    2.2.1 属性的封装

    属性的封装就是通过不同的修饰符去修饰属性,导致某些属性外部的可见性降低。外部不能随意修改以及获

    取。看下述代码:

    public class Quality {
    	private String name;
    	public 	Quality(){
    	}
    	public void method(){
    		System.out.println(name+"这是未设置的name");
    	}
    	//设置方法,使得调用该方法可以获得name的值
    	public void setName(String name){
    		this.name = name;
    	}
    	public String getName(){
    		return name;
    	}
    }
    public class QualityText {
    	public static void main(String[] args) {
    		Quality t = new Quality();
    		//t.name 这是会报错,因为在类Quality类中name被private修饰了,不可以调用
    		t.method();
    		t.setName("张三");
    		System.out.println(t.getName());
    	}
    }	
    
    • 这里就不去细说每个修饰符修饰属性后会表示什么结果,后期说到修饰符的时候我们再去细谈;
    • 用private修饰后就不可以通过对象.属性去调用属性了,它在其他类中是不可见的;
    • 一旦我们的属性被封装后,我们内部要有可见的方法去获取属性和设置属性,这样的话代码的可操作空间就获得了提升。

    2.2.2 构造器的封装

    实例代码:

    public class Constructor {
    	//将构造器封装,即用修饰词修饰
    	private Constructor(){
    	}
    	//创建一个方法去让其他类获取该类的对象 这个方法一定要用static修饰,没有对象所以要直接类名.方法调用到该方法
    	public static Constructor getConstructor(){
    		 return new Constructor();
    	}
    }
    public class ConstructorText {
    	public static void main(String[] args) {
    		Constructor t = Constructor.getConstructor();
    		System.out.println(t);
    		//输出结果是com.mage.encapsulation.Constructor@15db9742
    	}
    }
    
    • 我们假设一个类中所有的方法都是用static修饰的,那么我们就没有必要去创建该类的对象从而用对象.方法去调用方法了,我们只要类名.方法就可以直接拿过来用了,这个时候我们就要把该类的构造器给封装起来,避免在去创造该类的对象了,例如JDK中的Math类就是这样的,它里面的方法都是用static修饰的,就没必要再去创建对象了,这是Math类的构造器就被封装起来了。

    • 一般情况下对于构造器的封装都是有意义的,后期的单例模式、后期的一些工具类的创建都会将构

      造器私有起来。本质上构造器是否私有,构造器是否封装是有当前类所处的角色事先就定义好了。

    2.2.3 方法的封装

    编写代码,完成数组的添加元素,不考虑后期的维护

    public class Arrays {
    	private int[] arrs;
    	private int index;//咱们设置数的添加位置
    	public Arrays(){
    		arrs = new int[4];//一声明对象就给数组赋值为长度为4的数组
    		index = 0;//默认从数组索引为0的位置上添加元素
    	}
    	//往创建的对象中添加元素
    	public void add(int value){//表示添加的数
    		if(index>=arrs.length){
    			resize();
    		}
    		arrs[index] = value;
    		index++;
    	}
    	//这里的resize就可以是private修饰的,不需要给别人看到的
    	private void resize(){
    		int[] newarrs = new int[arrs.length*2];
    		for(int i=0;i<=arrs.length-1;i++){
    			newarrs[i] = arrs[i];
    		}
    		arrs = newarrs;
    	}
    	//编写toString方法,用法是直接输出该数值就是调用该数组的toString方法
    	public String toString(){
    		String result = "[";
    		String result1 = "";
    		for(int i:arrs){
    			result1+=i+" ";
    		}
    		String result2 = "]";
    		String set = result+result1+result2;
    		return set;
    	}
    	public int getLength(){
    		return arrs.length;
    	}	
    }
    

    对于这串代码中的resize即给数组扩容的方法我们就可以用private修饰,它不需要在其他类中调用,只要在本类中能看的到就可以,这样就将该方法给封装起来了。

    2.3 包和导包

    2.3.1 包

    1、 什么是包?

    包就是在java中用来存放.java文件的,类似文件夹的形式,它可以区分类。

    K1u9iT.png

    • 需要注意的是包下面的.java文件没有父子关系,都是独立存在的。
    • 编写代码是给类起名要注意不要和JDK内置的类同名了,java中的对象在通过输出语句直接输出是打印的内容是全限定名(包名.类名),通过全限定名去唯一标示一个类。java中的最小的单位就是类。
    2、如何定义一个类的包

    实例代码

    package com.mage.dingyi;
    
    public class Package {
    	int big;
    	public Package(){
    	}
    	public static void main(String[] args) {
    		System.out.println("我的第一个包文件");
    	}
    }
    
    • 通过package关键词来定义一个包
    • package必须放在类的外面且是第一行

    2.3.3 导包

    导包指的是你想调用的方法所属的类不在一个包下的时候,就要进行导包。

    示例代码:

    package com.mage.dingyi;
    
    //获取用户键盘输入的值
    import java.util.Scanner;
    public class PutIn {
    	public static void main(String[] args) {
    		Scanner input = new Scanner(System.in);
    		System.out.println("输入一个数");
    		int num = input.nextInt();
    		System.out.println(num);
    	}
    }
    

    总结:

    • 如果两个类处在同一个包下,那么不需要导包;
    • 不同包下的类想要互相调用必须导包;
    • 在package下面,类声明的上面通过import关键词+导入的类的全限定名;
    • 在java中java.lang包下的类是不需要导包的,可以直接使用;
    • 编写代码时如果出现需要导包的时候,可以使用ctrl+1来完成快速导包;
    • import java.util.*; 导入java.util下的所有内容;都是这样的,后面跟星符号就是表示为导入该包下的所有类;
    • 导包的目的就是为了能够使用其它包下的类。

    2.4 补充四个修饰符public,protected,默认的(即不写),private用法

    修饰符 同包子类 同包类 异包类 异包子类 本类
    public 可以 可以 可以 可以 可以
    protect 可以 可以 不可以 可以 可以
    默认的 可以 可以 不可以 不可以 可以
    private 不可以 不可以 不可以 不可以 可以
    • 使用修饰符一定程度上保证了方法,属性以及类的安全性;
    • 封装一定程度上打破了继承关系。

    port java.util.*; 导入java.util下的所有内容;都是这样的,后面跟星符号就是表示为导入该包下的所有类;

    • 导包的目的就是为了能够使用其它包下的类。

    2.4 补充四个修饰符public,protected,默认的(即不写),private用法

    修饰符 同包子类 同包类 异包类 异包子类 本类
    public 可以 可以 可以 可以 可以
    protect 可以 可以 不可以 可以 可以
    默认的 可以 可以 不可以 不可以 可以
    private 不可以 不可以 不可以 不可以 可以
    • 使用修饰符一定程度上保证了方法,属性以及类的安全性;
    • 封装一定程度上打破了继承关系。
    展开全文
  • 子类方法与超类同名...下面我们就以toString()方法为例,来看一下子类怎样来调用父类中的同名方法: 超类的toString()方法: [code="javascript"]Rectangle.prototype.toString=function(){ ...
  • 详述Java重写

    2019-07-30 11:55:54
    1.为什么重写 重写就是重新改写。将一个已有事物进行某些改变以适应新的要求。在Java中则为子类在继承父类的方法时已经不能“准确描述子类自身的行为特征了”,故...父类方法在子类中重写使继承更加灵活。 3.怎样...
  • java方法的应用举例

    千次阅读 2016-11-06 15:26:25
    我们已经讨论了方法的重写,也就是子类能够重写父类方法。 当子类对象调用重写的方法时,调用的是子类方法,而不是父类被重写的方法。 要想调用父类被重写的方法,则必须使用关键字super。 /* 文件名...
  • 重载: 同一个类方法名一样,但是参数不一样(即参数的数量或参数类型不能完全相同)重写父子类子类重写父类中方法。需要具有相同的方法名、参数、返回值。重载 就是可以创建多个方法,它们...
  • Java的虚方法

    2017-11-29 09:52:00
    如果在子类中定义某方法与其父类有相同的名称和参数,我们说该方法重写 (Overriding)。在Java中,子类可继承父类中的方法,而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类方法,而是想作一定...
  • 如果在子类中定义某方法与其父类有相同的名称和参数,我们说该方法重写 (Overriding)。在Java中,子类可继承父类中的方法,而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类方法,而是想作一定...
  • Java 多态 多态存在的三个必要条件 继承 重写 父类引用指向子类对象 当使用多态方式调用方法时,首先检查父类是否有该方法,如果没有,则编译...我们已经讨论了方法的重写,也就是子类能够重写父类方法。 当子...
  • 方法可以在子类中调用父类的属性和方法。 子类中没有和父类同名的属性时,通常省略super.。 子类没有对父类方法进行重写时,也会省略super.。 2. 对构造器 当父类中的属性是private时,子类对该属性赋值可以用...
  • 父类或接口定义了方法应该抛出的异常,那么当子类重写方法时应该怎样定义将要抛出的异常: 首先定义异常和父类: 1 class Exception1 extends Exception {} 2 class Exception2 extends Exception {} 3 ...
  • 但当子类中存在和父类同名的变量和方法时,分别用父类类型的变量、子类类型的变量去调用对象的实例变量和方法时,会有怎样的结果呢? 我们不妨来做个试验:定义一个Base类(父类),其中声明一个实例变量和实例...
  • Java抽象(多态)

    2020-10-12 17:22:28
    抽象类,限制实例化 1、不允许被直接实例化,只能被继承 2、可通过向上转型指向子类实例 应用场景:某些父类只是知道其子类应该包含怎样方法,但无法准确知道这些子类如何实现这些...1、某种行为能力不同子类中的表
  • Java 习题5 参考答案及解析(1)

    万次阅读 多人点赞 2017-06-07 23:45:03
    1.问答题 (1)子类可以有多个父类吗?...(5)子类重写方法的规则是怎样的?重写方法的目的是什么? (6)父类的final方法可以被子类重写吗? (7)什么类可以有abstract方法? (8)对象的上转型对象有
  • 总结

    2016-06-18 23:50:04
    怎样才能在子类中调用父类的同名方法: parent::需要调用的函数(); parent::可用于调用父类中定义的成员方法 parent:: 重写:  在子类中出现和父类同名的方法,这个称为重写;  行为的重新定义;  ...
  • 怎样理解多态

    千次阅读 2017-07-15 08:06:22
    比如,发生多态时,如果传入参数是一个子对象,那么会调用子对象对应的成员方法,如果传入参数是一个父对象,那么会调用父对象的成员方法.C++多态的实现:C++多态的实现需要三个条件.1.存在继承关系 2.子类重写父类...
  • 一、问答题 1.子类可以有多个父类吗?...5.子类重写方法的规则是怎样的?重写方法的目的是什么? 6.父类的final方法可以被子类重写吗? 7.什么类可以有abstract方法? 8.对象的上转型对象有怎样的特点? ...
  • 目录1. 概述2. 抽象方法3. 抽象类4. abstract关键字5. 抽象类简单案例5.1案例介绍5.2 案例分析5.3 示例代码 ...只能在子类中才能确定如何去实现方法体。例如:所有几何图形都应该具备一个计算面积的方
  • 不同的类型,有不同的属性和表现方法。 多态原理。多态的是函授指针 多态的实现效果 多态:相同的调用语句有多种不同的表现形态; 多态实现的三个条件 有继承、有virtual重写、有父类指针(引用)...
  • 一个类能够继承(inherit)还有一个类的方法(methods),属性(property)和其他特性。当一个类继承其他类时,... Swift ,类能够调用和訪问超类的方法,属性和附属脚本(subscripts),而且能够重写(overr...
  • 对于java的多态你是怎样理解的呢?很多人表示,自己对于多态的概念不是很清楚,那么下面就让我们一起来详细的了解一下吧。1、什么是多态?...使用前提-有类的继承、由子类父类方法重写;使用方式-通过父类...
  • javase注解

    2020-04-29 17:37:49
    例如:@Override(用在子类重写父类方法),@FunctionInterface(定义函数式接口),@Test(JUnit的,单元测试)。 注解的作用:写在“源码”,给“注解解析器”看的。告诉注解解析器,怎样编译、运行后面的代码...
  • 2) 重写继承子类父类方法重新定义,它们的方法名,返回值类型,参数类型,参数个数必须完全相同,它们的方法体可以不同,例如所有的类都继承自Object,都可以重写它的toString()方法怎样删除重复...
  • 最近又重温了一遍《java编程思想》,看的过程产生一个想法,java中继承关系的父子类,相同的方法会被重写,那相同的变量会怎样呢? 答案是变量没有重写之说,如果子类声明了跟父类一样的变量,那意谓着子类...

空空如也

空空如也

1 2
收藏数 39
精华内容 15
关键字:

怎样在子类中重写父类方法