黑馬程序員.bobo.DAY.7

時間 2019-11-05

原文原文鏈接

Day-7

1.面向對象(繼承-概述)

/* 將學生和工人的共性描述提取出來,單獨進行描述,
只要讓學生和公認與當杜描述的這個類有關係,就能夠
 
繼承:
1,提升了代碼的複用性.
2,讓類與類之間產生了關係,纔有了多態的特性.
3,
注意:千萬不要爲了獲取其它類的功能,簡化代碼而繼承.
必須是類與類之間所屬關係才能夠繼承.所屬關係is a.
 */
class Person
{
String name;
int age;
}
class Student extends Person
{
 
void study()
{
System.out.println("good study");
}
}
class Woeker extends Person
{
 
void work()
{
System.out.println("good work");
}
}
 
class ExtendsDemo
{
public static void main(String[] args)
{
System.out.println();
}
}

2面向對象(繼承-概述2)

/* 將學生和工人的共性描述提取出來,單獨進行描述,
只要讓學生和公認與當杜描述的這個類有關係,就能夠
 
繼承:
1,提升了代碼的複用性.
2,讓類與類之間產生了關係,纔有了多態的特性.
3,
注意:千萬不要爲了獲取其它類的功能,簡化代碼而繼承.
必須是類與類之間所屬關係才能夠繼承.所屬關係is a.
 class C
 {
void demo1(){}
 }
 
 class A extends C
 {
//void demo1(){}
void demo2(){}
 }
 class B extends C
 {
//void demo1(){}
void demo3(){}
 }
 
 java 語言中:Java只支持單繼承,不支持多繼承.
 由於多繼承容易帶來安全隱患:當多個父類中定義了相同功能,當功能內容不一樣時,子類不類不肯定要運行哪個
 可是Java保留這種機制,並用另外一種體現形態來完成表示.多實現.
 
 Java支持多層繼承.也就是一個繼承體系
 如何使用一個繼承體系中的個功能呢?
 
 想要使用體系,先查閱體系父類的描述.由於父類定義的是該體系中的共性功能
 經過了解共性功能,就能夠知道該體系的基本功能.
 那麼這個體系已經能夠基本使用了
 那麼在具體調用時,要建立子類的對象,爲何呢?
 一是由於有可能父類不能建立對象.
 二是建立子類對象能夠建立更多的功能,包括基本的也包括特有的
 
 簡單一句話:查閱父類功能,建立子類對象使用功能
 
 
 class A
{
void show()
{
System.out.println("a");
}
}
 class B
{
void show()
{
System.out.println("b");
}
}
 class C extends A,B
{
}
C c = new c();
c.show();
 */
class Person
{
String name;
int age;
}
class Student extends Person
{
void study()
{
System.out.println("good study");
}
}
class Woeker extends Person
{
void work()
{
System.out.println("good work");
}
}
 
class ExtendsDemo
{
public static void main(String[] args)
{
Student s = new Student();
s.name = "zhangsan";
}
}

3.面向對象(子父類中變量的特色)

/* 
子父類出現後,類成員的特色:
類中成員:
1,變量.
2,函數.
3,構造函數.
 
1,變量
若是子類子類中出現非私有的同名成員變量時,
子類要訪問本類中的變量,用this
子類要訪問父類中的變量,用super.
super 的使用和this的使用幾乎一致
this表明的的是本類的對象的引用.
super表明的是父類對象的引用.
 */
class Fu
{
 int num = 4;
}
class Zi extends Fu
{
//int num = 5;
void show()
{
System.out.println(num);
}
}
 
class ExtendsDemo2
{
public static void  main(String[] args)
{
Zi z = new Zi();
z.show();
//System.out.println(z.num+"...."+z.num);
}
}

4.面向對象(子父類中函數的特色)

/* 
子父類出現後,類成員的特色:
類中成員:
1,變量.
2,函數.
3,構造函數.
 
1,變量
若是子類子類中出現非私有的同名成員變量時,
子類要訪問本類中的變量,用this
子類要訪問父類中的變量,用super.
super 的使用和this的使用幾乎一致
this表明的的是本類的對象的引用.
super表明的是父類對象的引用.
2,子父類中的函數.
當子類出現和父類如出一轍的函數時,
當子類對象調用該函數,會運行子類函數的內容.
如同父類的函數被覆蓋同樣.
這種狀況是函數的另外一個特性:重寫(覆蓋)
 
 當子類繼承父類,沿襲了父類的功能,到子類中,
 可是子類歲具有該功能,可是功能的內容卻和父類不一致,
 這時,沒有定義新功能,而是使用覆蓋特殊,保留父類的功能定義,並重寫功能內容
 
 覆蓋:
 1,子類覆蓋父類,必須保證子類權限大於等於父類權限,才能夠覆蓋,不然編譯失敗.
 
 2,靜態只能覆蓋靜態.
 
 記住你們:
 重載:只看同名函數的參數的列表.
 重寫:子父類方法要如出一轍.
 */
class Fu
{
void show()
{
System.out.println("fu show");
}
 void speak()
{
System.out.println("vb");
}
}
class Zi extends Fu
{
void speak()
{
System.out.println("java");
}
//int num = 5;
 void show()
{
System.out.println("zi show");
}
}
 
class ExtendsDemo3
{
public static void  main(String[] args)
{
Zi z = new Zi();
z.speak();
 
//System.out.println(z.num+"...."+z.num);
}
}
 
class Tel
{
void show()
{
System.out.println("number");
}
}
class NewTel extends Tel
{
void show()
{
//System.out.println("number");
super.show();
System.out.println("name");
System.out.println("pic");
}
}

5.面向對象(子父類構造函數的特色)

/* 
3,子父類中的構造函數
 
在對子類進行對象進行初始化時,父類的構造函數也會運行,
那是由於子類的構造函數默認第一行有一條隱式的語句 super();
super():會訪問父類中空參數的構造函數.並且子類中全部的構造函數默認第一行都是super();
 
爲何子類必定要訪問父類中的構造函數.
 
由於父類中的數據子類能夠直接獲取,因此子類對象在創建時,須要先查看父類是如何對這些數據進行初始化的.
因此子類在對象初始化時,要先訪問一下父類中的構造函數
 若是要訪問父類中指定的構造函數,能夠經過手動定義super語句的方式來指定.
 
注意:super語句必定定義在子類構造函數的第一行.
 
子類的實例化過程.
結論:
子類的全部的構造函數,默認都會訪問父類中的空空參數的構造函數.
由於子類每個構造函數內的第一行都有一句隱式super();
 
當父類中沒有空參數的構造函數時,子類必須手動經過super或者this語句形式來指定要訪問父類中的構造函數.
 
固然,子類的構造函數第一行也能夠手動指定this語句來訪問本類中的構造函數.子類中至少會有一個構造函數會訪問父類中的構造函數.
 */
class Fu//extends Object 
{
int num ;
Fu()
{
//super();
num = 60;
System.out.println("fu run");
}
Fu(int x)
{
System.out.println("fu run");
}
}
class Zi extends Fu
{
Zi()
{
super();
//super(4);
System.out.println("zi run");
}
Zi(int x)
{
this();
//spuer();
//super(3);
System.out.println("zi...."+x);
}
}
 
class ExtendsDemo4
{
public static void  main(String[] args)
{
Zi z = new Zi();
System.out.println(z.num);
}
}
/* class Person 
{
Private String name;
Person(String name)
{
this.name = name;
}
void show(){}
}
class Student extends Person
{
Student(String name)
{
super(name);
}
void method()
{
super.show();
}
} */

6.面向對象(final關鍵字)

/*
final:最終.做爲一個修飾符,
1,能夠修飾類,函數,變量.
2,被final修飾的類不能夠被繼承.爲了不被繼承,被子類複寫功能.
3,被final修飾的方法不能夠被複寫.
4,被final修飾的變量是一個常量只能賦值一次,既能夠修飾成員變量,又能夠修飾局部變量.
當描述事物時,一些數據的出現值是固定的,那麼這時爲了加強閱讀性,都給這些值起個名字,方便於閱讀
而這個值不須要改變,因此加上final修飾,做爲常量,常量的書寫規範所遇字幕都大寫,若是由多個單詞組成.單詞間經過_鏈接
5,內部類定義在類中的局部位置上是,只能訪問該局部被finally修飾的局部變量.
 
*/
 
 class Demo
{
final int x= 3;
public static final double PI = 3.14;
final void show1()
{
}
void show2()
{
final int y = 4;
System.out.println(3.14);
}
}
class SubDemo extends Demo
{
//void show1(){}
}
class FinalDemo
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}

7.面向對象(抽象類)

/*
當多個類中出現相同功能,當時功能主體不一樣,
這是能夠進行向上抽取.這時,只抽取功能定義,而不抽取功能主體.
 
抽象:看不懂.
 
抽象類的特色:
1,抽象方法必定在抽象類中.
2,抽象方法和抽象類都必須被abstract關鍵字修飾.
3,抽象類不能夠用new 建立對象.由於調用抽象方法沒意義.
4,抽象類中的抽象方法要被使用,必須由子類複寫起全部的抽象方法後,簡歷子類對象調用.
若是子類只覆蓋了部分抽象方法.那麼該子類仍是一個抽象類.
*/
abstract class Student
{
abstract void study();
//abstract void study1();
}
class BaseStudent extends Student
{
void study()
{
System.out.println("base study");
}
}
class AdvStudent extends Student
{
void study()
{
System.out.println("adv study");
}
}
 
class AbstractDemo
{
public static void main(String[] args)
{
//new Student();
new BaseStudent().study();
}
}

8.面向對象(抽象類2)

/*
當多個類中出現相同功能,當時功能主體不一樣,
這是能夠進行向上抽取.這時,只抽取功能定義,而不抽取功能主體.
 
抽象:看不懂.
 
抽象類的特色:
1,抽象方法必定在抽象類中.
2,抽象方法和抽象類都必須被abstract關鍵字修飾.
3,抽象類不能夠用new 建立對象.由於調用抽象方法沒意義.
4,抽象類中的抽象方法要被使用,必須由子類複寫起全部的抽象方法後,簡歷子類對象調用.
若是子類只覆蓋了部分抽象方法.那麼該子類仍是一個抽象類.
 
抽象類和通常類沒有太大的不一樣
該如何描述事物,就如何描述事物,只不過該事物出現了一些看不懂的東西,
這些不肯定的部分,也是該事物的,須要明確出現,可是沒法定義主體.
經過抽象方法來表示.
 
抽象類比通常類多個抽象函數.就是在類中能夠定義抽象方法.
抽象類不能夠實例化.
 
特殊:抽象類中能夠不定義抽象方法,這樣作僅僅是不讓該類創建對象.
 
*/
abstract class Student
{
abstract void study();
//abstract void study1();
vois sleep()
{
System.out.println("躺着");
}
}
class ChongCiStudent extends Student 
{
void study()
{
System.out.println("chongci study");
}
}
class BaseStudent extends Student
{
void study()
{
System.out.println("base study");
}
}
class AdvStudent extends Student
{
void study()
{
System.out.println("adv study");
}
}
 
class AbstractDemo
{
public static void main(String[] args)
{
//new Student();
new BaseStudent().study();
}
}

9.面向對象(抽象類練習)

/* 
假如咱們在開發一個系統時須要對員工進行建模,員工包含3個屬性:
姓名、工號以及工資.經理也是員工,除了含有員工的屬性外,另爲還有一個獎金屬性,請使用繼承的思想設計員工類和經理類,要求類中提供必要的方法進行屬性訪問.
 
 員工類:name id pay
 經理類:繼承了員工,並有本身特有的bonus.
 */
 
class Employee
{
private String name;
private String id;
private double pay;
Employee(String name,String id,double pay)
{
this.name = name;
this.id = id;
this.pay = pay;
}
public abstract void work();
}
class Manager extends Employee
{
private int bonus;
Manager(String name,String id,double pay,int bonus)
{
super(name,id,pay);
this.bonus = bonus;
}
public void work()
{
System.out.println("manager work");
}
}
class Pro extends Employee
{
Pro(String name,String id,double pay)
{
Super(name,id,pay);
}
public void work()
{
System.out.println("pro work");
}
}
 
class AbstractTest
{
public static void main(String[] args)
{
System.out.println();
}
}

10.面向對象(模版方法模式)

/*
需求:獲取一段程序運行的時間.
原理:獲取程序開始和結束的時間並相減便可.
 
獲取時間:System.currentTimeMillis(); 
 
 當代碼完成優化後,就能夠解決這類問題.
 這種方式,模版方法設計模式.
 
 什麼是模版方法呢?
 在定義功能屎,功能的一部分是肯定的,可是有一部分是不肯定,而肯定的部分在使用不肯定的部分,那麼這時就將不肯定的部分暴露出去.由該類的子類去完成.
 */
 
 abstract class GetTime
 {
public final void getTime()
{
long start = System.currentTimeMillis();
runcode();
long end = System.currentTimeMillis();
System.out.println("毫秒:"+(end-start));
}
public abstract void runcode();
 }
 
 
 class SubTime extends GetTime
 {
public void runcode()
{
 for(int x=0;x<4000;x++)
 {
System.out.print(x);
 }
 
}
 }
class TemplateDemo
{
public static void main(String[] args)
{
//GetTime gt = new GetTime();
SubTime gt = new SubTime();
gt.getTime();
}
}

11.面向對象(接口)

/* 
接口:初期理解,能夠認爲是一個特殊的抽象類
當抽象類中的方法都是抽象的,那麼該類能夠經過接口的形式來表示.
class 用於定義類
interface 用於定義接口.
 
接口定義時,格式特色:
1,接口的常見定義:常量,抽象方法.
2,接口中的成員都有固定的修飾符.
常量:public static final
方法:public abstract
記住:接口中的成員都是public的.
接口:是不能夠建立對象的,由於有抽象方法.
須要被子類實現,子類對接口中的抽象方法全都覆蓋後,子類才能夠實例化.
不然子類是一個抽象類.
*/
interface Inter
{
public static final int NUM =3;
public abstract void show();
}
class Test implements Inter 
{
public  void show(){}
}
class InterfaceDemo
{
public static void main(String[] args)
{
Test t = new Test();
System.out.println(t.NUM);
System.out.println(Test.NUM);
System.out.println(Inter.NUM);
}
}

12.面向對象(接口2)

/* 
接口:初期理解,能夠認爲是一個特殊的抽象類
當抽象類中的方法都是抽象的,那麼該類能夠經過接口的形式來表示.
class 用於定義類
interface 用於定義接口.
 
接口定義時,格式特色:
1,接口的常見定義:常量,抽象方法.
2,接口中的成員都有固定的修飾符.
常量:public static final
方法:public abstract
記住:接口中的成員都是public的.
接口:是不能夠建立對象的,由於有抽象方法.
須要被子類實現,子類對接口中的抽象方法全都覆蓋後,子類才能夠實例化.
不然子類是一個抽象類.
 
接口能夠被類多實現,也是對多繼承不支持的轉換形式.Java支持多實現.
*/
interface Inter
{
public static final int NUM =3;
public abstract void show();
}
interface InterA
{
public abstract void  show();
}
class Demo
{
public void function(){}
}
class Test extends Demo implements Inter,InterA
{
public void show(){}
}
 
interface A
{
void methodA();
int show();
}
interface B //extends A
{
void methodB();
boolean show();
}
interface C extends B,A
{
void methodC();
}
class D implements C
{
public void methodA(){}
public void methodC(){}
public void methodB(){}
public int show(){}
public boolean show(){}
}
 
 
class InterfaceDemo
{
public static void main(String[] args)
{
Test t = new Test();
System.out.println(t.NUM);
System.out.println(Test.NUM);
System.out.println(Inter.NUM);
}
}

13.面向對象(接口的特色)

沒聽懂java

14.面向對象(接口舉例體現)

/* class Student
{
abstract void study();
void sleep()
{
System.out.println("sleep");
}
}
 
interface Smoking
{
void smoke();
}
class ZhangSan extends Student implements Smoking
{
void study(){}
public void smoke(){}
}
class Lisi extends Student
{
} 
abstrct class Sporter
{
abstrct void play();
}
interface Study
{
}
class wangwu extends Sport implements Study  
{
 
}
*/
 
 
class
{
public static void main(String[] args)
}