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";
}
}