java重写

Ⅰ java 如何重写一个文件

直接上代码：

Filef=newFile("my.txt");
if(!f.exsit()){
f.getParentFile().mkdirs();//创建父目录
f.createNewFile();//创建文件自身
}
FileWriterfw=null;]
try{
fw=newFileWriter(f);
fw.write("我的内容
");
fw.write("我的内容
");
fw.close();
}catch(Throwablee){e.printStackTrace();//把异常给输出出来
}finally{
if(fw!=null)try{fw.close();}catch(Throwablee){)//关闭文件

}

Ⅱ java中的方法重写

理论上说方法重写只要参数列表和名称相同就可以认为已经是重写~~不过方法重写一般都和原来的方法一摸一样~~也就是方法名、参数列表、返回值都和原方法一样~~要实现方法重写的话必须得继承相应的父类~~并且在子类里有一个和父类的某一个方法相同的一个方法~~如果是在本类里存在的相同的方法是重载而不是重写~~

Ⅲ Java重写方法

问题一：我们自定义类中的toString()、hashCode()和equals(Object obj)均继承自Object，其中equals()方法是比较两对象的地址是否相同，hashCode()方法返回的是该对象本身的内存地址。但这个需求不能满足我们的需求。如问题二。(JDK中其它类都已重写了上述方法，不作考虑） 问题二：在我们往HashSet中添加自定义对象的时候（HashSet中不能添加相同的对象），HashSet会先将已存在的对象与欲添加的对象进行一一对比，相同的对象不允许再添加。其比较规则为：如果两对象的hashCode()方法返回值不一样，肯定不是相同的对象，可添加；如果hashCode()一样，则再判断equals()返回是否为真，不为真则肯定不是相同的对象，可添加，为真由证明两对象完全相同，不再添加到HashSet中。那按Object()中的hashCode()方法，则只要内存不一样，则两对象的hashCode就不一样，则认为两对象不相同，可往HashSet中添加，这违背了我们实际需求。 结论：我们自定义类如果想往HashSet等集合中添加时，必须重写equals(Object obj)和hashCode()方法，使相同内容的对象其equals(Object obj)为真，返回的hashCode()一致。如下：public class Stu {
private String name;
private int age;
@Override
public boolean equals(Object obj) {

if(!(obj instanceof Stu)){
return false;
}
if(obj==null){
return false;
}
Stu tmp=(Stu)obj;
if(tmp.age!=this.age && !tmp.name.equals(this.name)){
return false;
}
return true;
}
@Override
public int hashCode() {
return this.age*this.name.hashCode();
}
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;
}
}测试类：
import java.util.HashSet;
public class Test {
public static void main(String[] args) {
Stu s1=new Stu();
s1.setAge(18);
s1.setName("abc");
Stu s2=new Stu();
s2.setAge(18);
s2.setName("abc");
System.out.println(s1==s2);
System.out.println(s1.equals(s2));
HashSet set=new HashSet();
set.add(s1);
set.add(s2);
System.out.println(set.size());
}
}在上面的测试中两对象的年龄与姓名均一致，但其内存地址不一样。所以用"=="为假，用equals为真，返回的set.size()为1，即往HashSet中只能添加进一个对象。至于toString()方法较为简单，不多说了……

Ⅳ java中方法重写的实例子

importjava.util.*;
publicclasszilei{
publicstaticvoidmain(Stringarg[]){
System.out.println("请输入两个正整数：");
Scannerreader=newScanner(System.in);
inta=reader.nextInt();
intb=reader.nextInt();
Aaa;
Bbb;
aa=newA();
bb=newB();
intd=aa.f(a,b);
System.out.println("最大公约数："+d);
intk=bb.f(a,b);
System.out.println("最小公倍数："+k);
}
}
classA{
publicintf(inta,intb){
intr=a%b;
while(r!=0){
a=b;
b=r;
r=a%b;
}
returnb;
}
}
classBextendsA{
publicintf(inta,intb){
intm=super.f(a,b);
return((a*b)/m);
}
}
这里classB的f(inta,intb)方法就重写了父类的相同方法。

Ⅳ Java中重写

你这里说的其实是JAVA里面的多态，即同样是Parent的引用xxx，xxx.print()方法实际调用了不同的方法。
print()实际调用的方法要看你实例化出来的对象，比如你
Parent p = new Parent("south", "north");那么p.print();调用的就是Parent.print()方法，
Parent t = new Child("east", "west");t.print();调用的就是Child.print();方法，
同时如果你还有另一个类B extends Parent，并重写print()方法，那么你Parent b = new B();b.print();调用的就是B.print();方法。

Ⅵ Java中的重写

在Java中如何来定义重写：Java程序中类的继承特性可以产生一个子类，子类继承父类就拥有了父类的非私有的属性（方法和变量），在子类中可以增加自己的属性（方法和变量），同时也可以对父类中的方法进行扩展，以增强自己的功能，这样就称之为重写，也称为复写或者覆盖。所谓方法重写就是子类的方法和父类中继承下来的方法具有完全相同的方法名、返回值类型、方法的参数个数以及参数类型，这样才能被称为方法重写。
代码体现：
// 这是父类的定义
public class Person {
public void eat() {
System.out.println("=====这是父类Person的eat方法=======");
}
}

// 这是子类的定义
public class Student extends Person {
@Override
public void eat() {
System.out.println("===这是子类Student的eat方法===");
}

// main方法测试
public static void main(String[] args) {
Student student = new Student();
student.eat(); //输出：===这是子类Student的eat方法===
}
}
子类重写父类的方法后，在实例化子类的时候则调用的是子类中的方法，父类的方法就如同被覆盖了一样。如果在子类中需要调用父类的方法，则在子类方法中使用super关键字调用父类的方法，格式：super.父类中的方法名。

Ⅶ java 重写方法

final 和static 的方法不能被重写 但是静态的方法可以被重新定义
你那个不是重写 是重新定义 重新定义不属于多态范畴
所以他只看引用类型 但是java也强烈建议你千万不要用引用去访问静态变量或静态方法，因为那样你会逻辑混乱
你用的f其实就是子类型，根本没有多态的，就算是调用重写的非静态方法还是体现不出多态性
那么其调用的grow一定是重新定义的子类方法
然而
Amphibian.grow(f);
来说 你在grow参数里声明的是父类的引用 但是你却把一个子类实例传递进来
多态性在这体现了 首先调用的是父类的静态没疑问了 然而a.eat();出现了多态行为
父类引用指向子类对象 调用的是子类重写的方法

Ⅷ java怎么重写一个方法

抽象方法：在类中没有方法体的方法，就是抽象方法。
你类中的抽象方法就没有里面的语句，也就是说你这根本就不符合抽象方法的定义。

如果不是抽象方法super.get()
class A{
void get(){ int i=1;i++;}
}
public class B extends A{
public static void main(String args[]) {

B b = new B();
b.get();
}

void get(){
super.get();
}

}

Ⅸ java重写已定义好的类中的方法

1、新建一个类继承定义好的类， 然后重新实现定义好的类中的方法。
2、可以修改参数的个数和类型重新实现这个方法。
比如现在有一个cat类
class Cat{
public void say(){
system.out.println("miao~")

}

}
我们可以定义一个小猫来继承这个类
class SmallCat extends Cat{
public void say(){
system.out.println("miaowu`~")

}

}
也可以在cat类里新增say方法：
class Cat{
public void say(){
system.out.println("miao~")

}
public void say(String sound)
{
system.out.println(sound);
}

}

Ⅹ java中方法重写具体是什么

方法重写，就是一个类继续了另一个类的时候，对父类的方法重新实现！

这个重新实现，就是使用相同的方法名，相同的参数列表和返回类型，访问控制符使用和父类相同或者更宽。

举例：
class F {
public String m(String s) {
return s;
}
}

class C extends F {
@Override
public String m(String s) {
return s+"extends";
}
}