諾基亞等廠商加入智慧化浪潮後，功能機會迎來第二春嗎
1.1 類與類之間的關係
A:繼承(extends)
* 讓類與類之間產生關係,子父類關係
* 繼承就是子類繼承父類的特徵和行為，使得子類物件（例項）具有父類的屬性和方法，或子類從父類繼承方法，使得子類具有父類相同的行為。
特點：子類具有父類的所有屬性和方法，並擁有自己的獨有的屬性和行為。
B:繼承案例演示：
* 動物類,貓類,狗類
* 定義兩個屬性(顏色,腿的個數)兩個功能(吃飯，睡覺)
程式碼：
public class Demo1_extends {
public static void main(String[] args) {
Dog dog = new Dog();dog.eat();
dog.sleep();
}
}
/**
* 1.建立動物類，也就是父類
* 2.屬性：動物的顏色，腿的的個數
* 3. 方法：吃飯，睡覺
*/
class Animal{
String color;
int leg;
public void eat(){
System.out.println("正在吃");
}
public void sleep(){
System.out.println("睡覺");
}
}
class Cat extends Animal{
}
class Dog extends Animal {
}
1.2繼承的好處與弊端
* A:繼承的好處
* a:提高了程式碼的複用性
* b:提高了程式碼的維護性
* c:讓類與類之間產生了關係，是多型的前提
* B:繼承的弊端
* 類的耦合性增強了。
* 開發的原則：高內聚，低耦合。
* 耦合：類與類的關係
* 內聚：就是自己完成某件事情的能力
1.3 Java中類的繼承特點
* A:Java中類的繼承特點
* a:Java只支援單繼承，不支援多繼承。(一個兒子只能有一個爹)
* 有些語言是支援多繼承，格式：extends 類1,類2,...
* b:Java支援多層繼承(繼承體系)
* B:案例演示
* Java中類的繼承特點
* 如果想用這個體系的所有功能用最底層的類建立物件
* 如果想看這個體系的共性功能,看最頂層的類
程式碼：
public class Demo2_extends {
public static void main(String[] args) {
Demo3 demo3 = new Demo3();
demo3.print();
demo3.method();
demo3.show();
System.out.println("----------------------");
Demo1 demo1 = new Demo1();
demo1.show();
}
}
class Demo1 {
public void show(){
System.out.println("Demo1");
}
}
class Demo2 extends Demo1{
public void method(){
System.out.println("Demo2");
}
}
class Demo3 extends Demo2{ // 包含了最多功能
public void print(){
System.out.println("Demo3");
}
}
1.4 Java中繼承的注意事項
* A:繼承的注意事項
* a:子類只能繼承父類所有非私有的成員(成員方法和成員變數)
* b:子類不能繼承父類的構造方法，但是可以通過super(馬上講)關鍵字去訪問父類構造方法。
* c:不要為了部分功能而去繼承
* 專案經理 姓名 工號 工資 獎金
* 程式設計師 姓名 工號 工資
* B:什麼時候使用繼承
* 繼承其實體現的是一種關係："is a"。
Person
Student
Teacher
水果
蘋果
香蕉
橘子
採用假設法。
如果有兩個類A,B。只有他們符合A是B的一種，或者B是A的一種，就可以考慮使用繼承。
程式碼：
public class Demo3_extends {
public static void main(String[] args) {
Programmer p = new Programmer();
p.setEno("1001");
p.setName("程式設計師");
p.setSalary(10000);
System.out.println(p.getEno() +"...." + p.getName() + "...." + p.getSalary());
System.out.println("++++++++++++");
ProjectManager pro = new ProjectManager();
pro.setEno("0001");
pro.setName("專案經理");
pro.setSalary(20000);
pro.setBonus(5000);
System.out.println(pro.getEno() +"...." + pro.getName() + "...." +
pro.getSalary() + "...." + pro.getBonus());
}
}
class Person{
private String name; // 員工的姓名
private String eno; // 員工的編號
private double salary; // 員工的工資
// 無引數的構造方法
public Person(){
}
// 有引數的構造方法
public Person(String name, String eno, double salary){
this.name = name;
this.eno = eno;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getEno() {
return eno;
}
public void setEno(String eno) {
this.eno = eno;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
}
class Programmer extends Person{
}
class ProjectManager extends Person{
private double bonus;
public double getBonus() {
return bonus;
}
public void setBonus(double bonus) {
this.bonus = bonus;
}
}
1.5繼承中成員變數的關係
* A:案例演示
* a:不同名的變數
* b:同名的變數
子父類出現同名的變數只是在講課中舉例子用,在開發中是不會出現這種情況的
子類繼承父類就是為了使用父類的成員,那麼如果定義了同名的成員變數沒有意義了
2.1 繼承中構造方法的關係
*A:案例演示
*子類中所有的構造方法預設都會訪問父類中空引數的構造方法
*B:為什麼呢?
*因為子類會繼承父類中的資料，可能還會使用父類的資料。
*所以，子類初始化之前，一定要先完成父類資料的初始化。
*其實：
*每一個構造方法的第一條語句預設都是：super() Object類最頂層的父類。
程式碼：
public class Demo5_Extends {
public static void main(String[] args) {
/**
* 1. 建立物件時，構造方法會自動執行
* 2. 建立的是子類的物件，但是父類的構造方法先執行了。
*/
Son2 son2 = new Son2();
}
}
class Father2 {
String name;
public Father2() {
System.out.println("Father 的構造方法");
}
}
class Son2 extends Father2 {
public Son2() {
System.out.println("Son 的構造方法");
}
}
2.2繼承中構造方法的注意事項
* A:案例演示
* 父類沒有無參構造方法,子類怎麼辦?
* super解決
* this解決
* B:注意事項
* super(…)或者this(….)必須出現在構造方法的第一條語句上
程式碼：
public class Demo6_Extends {
public static void main(String[] args) {
/**
* 1. 建立一個子類的物件
* 2. 呼叫子類的無引數的構造方法
* 3. 呼叫super("張三"， 7)方法執行父類中有引數的構造方法
* 4. 執行子類中的無引數的構造方法
*/
SonOne s1 = new SonOne();
System.out.println(s1.getName() + "..." + s1.getAge());
System.out.println("--------------------");
/**
* 1. 呼叫子類的有引數的構造方法
* 2. 呼叫super("李四"， 28)方法執行父類中有引數的構造方法
* 3. 執行子類中有引數的構造方法
*/
SonOne s2 = new SonOne("李四",28);
System.out.println(s2.getName() + "..." + s2.getAge());
}
}
class FatherOne{
private String name; // 姓名
private int age; // 年齡
/*
// 無引數的構造方法
public FatherOne() {
System.out.println("FatherOne: 空參構造方法");
}*/
// 有引數的構造方法
public FatherOne(String name, int age){
this.name = name;
this.age = age;
System.out.println("FatherOne: 有引數的構造方法");
}
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;
}
}
class SonOne extends FatherOne{
public SonOne() { //空參構造
super("張三", 7); //無論寫沒寫super() 方法，這一句話都會執行
System.out.println("Son 空參構造");
}
public SonOne(String name,int age) { //有參構造
super(name,age);
System.out.println("Son 有參構造");
}
}
public class Demo6_Extends {
public static void main(String[] args) {
/**
* 1. 建立一個子類的物件
* 2. 呼叫子類的無引數的構造方法
* 3. 呼叫super("張三"， 7)方法執行父類中有引數的構造方法
* 4. 執行子類中的無引數的構造方法
*/
SonOne s1 = new SonOne();
System.out.println(s1.getName() + "..." + s1.getAge());
System.out.println("--------------------");
/**
* 1. 呼叫子類的有引數的構造方法
* 2. 呼叫super("李四"， 28)方法執行父類中有引數的構造方法
* 3. 執行子類中有引數的構造方法
*/
SonOne s2 = new SonOne("李四",28);
System.out.println(s2.getName() + "..." + s2.getAge());
}
}
class FatherOne{
private String name; // 姓名
private int age; // 年齡
/*
// 無引數的構造方法
public FatherOne() {
System.out.println("FatherOne: 空參構造方法");
}*/
// 有引數的構造方法
public FatherOne(String name, int age){
this.name = name;
this.age = age;
System.out.println("FatherOne: 有引數的構造方法");
}
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;
}
}
class SonOne extends FatherOne{
public SonOne() { //空參構造
super("張三", 7); //無論寫沒寫super() 方法，這一句話都會執行
System.out.println("Son 空參構造");
}
public SonOne(String name,int age) { //有參構造
super(name,age);
System.out.println("Son 有參構造");
}
}