JAVA語言基礎-面向對象(方法重寫概述及其應用)
- A:什麼是方法重寫
- 重寫:子父類出現瞭如出一轍的方法(注意:返回值類型能夠是子父類,這個咱們學完面向對象講)
- B:方法重寫的應用：
- 當子類須要父類的功能，而功能主體子類有本身特有內容時，能夠重寫父類中的方法。這樣，即沿襲了父類的功能，又定義了子類特有的內容。
- C:案例演示
- a:定義一個手機類。
class Demo7_Phone {
public static void main(String[] args) {
Ios8 i = new Ios8();
i.siri();
i.call();
}
}
/*
B:方法重寫的應用：
* 當子類須要父類的功能，而功能主體子類有本身特有內容時，能夠重寫父類中的方法。這樣，即沿襲了父類的功能，又定義了子類特有的內容。
ios7系統 siri speak English
ios8系統 siri 說中文
*/
class Ios7 {
public void call() {
System.out.println("打電話");
}
public void siri() {
System.out.println("speak English");
}
}
class Ios8 extends Ios7 {
public void siri() {
System.out.println("說中文");
super.siri();
}
}
面向對象(方法重寫的注意事項)(掌握)
-
A:方法重寫注意事項ios
- a:父類中私有方法不能被重寫
- 由於父類私有方法子類根本就沒法繼承
- b:子類重寫父類方法時，訪問權限不能更低
- 最好就一致
-
c:父類靜態方法，子類也必須經過靜態方法進行重寫面試
- 其實這個算不上方法重寫，可是現象確實如此，至於爲何算不上方法重寫，多態中我會講解(靜態只能覆蓋靜態)
-
子類重寫父類方法的時候，最好聲明如出一轍。ide
- a:父類中私有方法不能被重寫
- B:案例演示
- 方法重寫注意事項
class Demo8_雙槳 {
public static void main(String[] args) {
DayOne d = new DayOne();
d.泡妞();
d.print();
}
}
/*
* a:父類中私有方法不能被重寫
* 由於父類私有方法子類根本就沒法繼承
* b:子類重寫父類方法時，訪問權限不能更低
* 最好就一致
* c:父類靜態方法，子類也必須經過靜態方法進行重寫
* 其實這個算不上方法重寫，可是現象確實如此，至於爲何算不上方法重寫，多態中我會講解(靜態只能覆蓋靜態)
* 子類重寫父類方法的時候，最好聲明如出一轍。
*/
class 雙槳 {
public void sing() {
System.out.println("唱紅歌");
}
public void 泡妞() {
System.out.println("唱紅歌搞定林夕合鳥女士");
}
public static void print() {
System.out.println("Fu print");
}
}
class DayOne extends 雙槳 {
public void 泡妞() {
System.out.println("霸王硬上弓");
}
public static void print() { //靜態只能覆蓋靜態,其實不算重寫,多態時候詳細講解
System.out.println("Zi print");
}
}
面向對象(方法重寫的面試題)(掌握)
-
A:方法重寫的面試題學習
- Override和Overload的區別?Overload能改變返回值類型嗎?
- overload能夠改變返回值類型,只看參數列表
-
方法重寫：子類中出現了和父類中方法聲明如出一轍的方法。與返回值類型有關,返回值是一致(或者是子父類)的this
-
方法重載：本類中出現的方法名同樣，參數列表不一樣的方法。與返回值類型無關。spa
-
子類對象調用方法的時候：code
- 先找子類自己，再找父類。
class Test3_Person {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
/*
* 使用繼承前的學生和老師案例
* 屬性:姓名,年齡
* 行爲:吃飯
* 老師有特有的方法:講課
* 學生有特有的方法:學習
*/
class Student {
private String name; //姓名
private int age; //年齡
public Student() {} //空參構造
public Student(String name,int age) { //有參構造
this.name = name;
this.age = age;
}
public void setName(String name) { //設置姓名
this.name = name;
}
public String getName() { //獲取姓名
return name;
}
public void setAge(int age) { //設置年齡
this.age = age;
}
public int getAge() { //獲取年齡
return age;
}
public void eat() { //吃飯
System.out.println("學生吃飯");
}
public void study() { //學習
System.out.println("學生學習");
}
}
class Teacher {
private String name; //姓名
private int age; //年齡
public Teacher() {} //空參構造
public Teacher(String name,int age) { //有參構造
this.name = name;
this.age = age;
}
public void setName(String name) { //設置姓名
this.name = name;
}
public String getName() { //獲取姓名
return name;
}
public void setAge(int age) { //設置年齡
this.age = age;
}
public int getAge() { //獲取年齡
return age;
}
public void eat() { //吃飯
System.out.println("老師吃飯");
}
public void teach() { //學習
System.out.println("老師講課");
}
}
class Test4_Person {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("張三");
s1.setAge(23);
System.out.println(s1.getName() + "..." + s1.getAge());
s1.eat();
s1.study();
System.out.println("------------------");
Student s2 = new Student("李四",24);
System.out.println(s2.getName() + "..." + s2.getAge());
s2.eat();
s2.study();
}
}
/*
* 使用繼承後的學生和老師案例
*/
class Person {
private String name; //姓名
private int age; //年齡
public Person() {} //空參構造
public Person(String name,int age) { //有參構造
this.name = name;
this.age = age;
}
public void setName(String name) { //設置姓名
this.name = name;
}
public String getName() { //獲取姓名
return name;
}
public void setAge(int age) { //設置年齡
this.age = age;
}
public int getAge() { //獲取年齡
return age;
}
public void eat() { //吃飯
System.out.println(name + "吃飯");
}
}
class Student extends Person {
public Student() {} //空參構造
public Student(String name,int age) {
super(name,age);
}
public void study() {
System.out.println(this.getName() + "學習");
}
}
class Teacher extends Person {
public Teacher() {} //空參構造
public Teacher(String name,int age) {
super(name,age);
}
public void teach() {
System.out.println(this.getName() + "講課");
}
}
class Test5_Animal {
public static void main(String[] args) {
Cat c1 = new Cat("花",4);
System.out.println(c1.getColor() + "..." + c1.getLeg());
c1.eat();
c1.catchMouse();
Dog d1 = new Dog("黑",2);
System.out.println(d1.getColor() + "..." + d1.getLeg());
d1.eat();
d1.lookHome();
}
}
/*
* A:貓狗案例分析
* B:案例演示
* 貓狗案例繼承版
* 屬性:毛的顏色,腿的個數
* 行爲:吃飯
* 貓特有行爲:抓老鼠catchMouse
* 狗特有行爲:看家lookHome
*/
class Animal {
private String color; //毛的顏色
private int leg; //腿的個數
public Animal(){}
public Animal(String color,int leg) {
this.color = color;
this.leg = leg;
}
public void setColor(String color) { //設置顏色
this.color = color;
}
public String getColor() { //獲取顏色
return color;
}
public void setLeg(int leg) { //設置腿的個數
this.leg = leg;
}
public int getLeg() { //獲取腿的個數
return leg;
}
public void eat() { //吃飯
System.out.println("吃飯");
}
}
class Cat extends Animal {
public Cat() {} //空參構造
public Cat(String color,int leg) { //有參構造
super(color,leg);
}
public void eat() { //吃魚
System.out.println("貓吃魚");
}
public void catchMouse() { //抓老鼠
System.out.println("抓老鼠");
}
}
class Dog extends Animal {
public Dog() {} //空參構造
public Dog(String color,int leg) { //有參構造
super(color,leg);
}
public void eat() { //吃肉
System.out.println("狗吃肉");
}
public void lookHome() { //看家
System.out.println("看家");
}
}
###08.19_面向對象(final關鍵字修飾類,方法以及變量的特色)(掌握)
* A:final概述
* B:final修飾特色
* 修飾類，類不能被繼承
* 修飾變量，變量就變成了常量，只能被賦值一次
* 修飾方法，方法不能被重寫
* C:案例演示
* final修飾特色對象
class Demo1_Final {
public static void main(String[] args) {
Son s = new Son();
s.print();
}
}
/*
* A:final概述
final是最終的
* B:final修飾特色
* 修飾類，類不能被繼承
* 修飾變量，變量就變成了常量，只能被賦值一次
* 修飾方法，方法不能被重寫
* C:案例演示
* final修飾特色
*/
/*final class Father {
public void print() {
System.out.println("訪問底層數據資源");
}
}*/
class Son /*extends Father*/ {
final int NUM = 10; //常量命名規範,若是是一個單詞,全部字母大寫,若是是多個單詞,每一個單詞都大寫,中間用下劃線隔開
public static final double PI = 3.14; //final修飾變量叫作常量,通常會與public static共用
public void print() {
//NUM = 20;
System.out.println(NUM);
}
}
###08.20_面向對象(final關鍵字修飾局部變量)(掌握)
* A:案例演示
* 方法內部或者方法聲明上都演示一下(瞭解)
* 基本類型，是值不能被改變
* 引用類型，是地址值不能被改變,對象中的屬性能夠改變繼承
class Demo2_Final {
public static void main(String[] args) {
final int num = 10;
//num = 20;
System.out.println(num);
final Person p = new Person("張三",23);
//p = new Person("李四",24);
p.setName("李四");
p.setAge(24);
System.out.println(p.getName() + "..." + p.getAge());
method(10);
method(20);
}
public static void method(final int x) {
System.out.println(x);
}
}
/*
* A:案例演示
* 方法內部或者方法聲明上都演示一下(瞭解)
* 基本類型，是值不能被改變
* 引用類型，是地址值不能被改變,對象中的屬性能夠改變
*/
class Person {
private String name; //姓名
private int age; //年齡
public Person(){} //空參構造
public Person(String name,int age) {
this.name = name;
this.age = age;
}
public void setName(String name) { //設置姓名
this.name = name;
}
public String getName() { //獲取姓名
return name;
}
public void setAge(int age) { //設置年齡
this.age = age;
}
public int getAge() { //獲取年齡
return age;
}
}
###08.21_面向對象(final修飾變量的初始化時機)(掌握)
* A:final修飾變量的初始化時機
* 顯示初始化
* 在對象構造完畢前便可資源
class Demo3_Final {
public static void main(String[] args) {
Demo d = new Demo();
d.print();
}
}
/*
* A:final修飾變量的初始化時機
* 顯示初始化
* 在對象構造完畢前便可
*/
class Demo {
final int num; //成員變量的默認初始化值是無效值
public Demo() {
num = 10;
}
public void print() {
System.out.println(num);
}
}
相關文章
- 1. Java基礎之面向對象概述
- 2. Java基礎（六）★方法★面向對象★重載★重寫
- 3. JAVA語言基礎-面向對象（IO：File）
- 4. java面向對象基礎語法——重寫，super，this，final
- 5. JAVA語言基礎-面向對象(構造方法)
- 6. Java 面向對象概述
- 7. JAVA語言基礎-面向對象（IO：IO其餘的流）
- 8. Java面向對象語法基礎
- 9. java基礎語法-面向對象(1)
- 10. C語言之面向對象基礎
- 更多相關文章...
- • R 語言基礎 - R 語言教程
- • PHP 面向對象 - PHP教程
- • Kotlin學習（一）基本語法
- • Java Agent入門實戰（二）-Instrumentation源碼概述
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
歡迎關注本站公眾號,獲取更多信息
