0716 Employee/Student/ 實參與形參 /方法的重載/Animal 繼承


   day02

類與對象
   什麼是對象?
     一切皆對象,具體的事物
   一個人(張三),一隻狗(旺財),一隻貓(花花)...

  什麼是類?
      具有相同特徵和行爲的對象的集合,類是抽象的概念
      沒有實體
   人類
   狗類
   貓類...


類 --- 月餅模子
對象 --- 月餅

類的基本結構(javaBean)
   私有的成員變量
   空參的構造方法
   有參的構造方法
   set get方法
   其他的業務方法

練習:
   創建一個員工類
    屬性:員工編號 姓名 性別 年齡 薪資 部門
    行爲:展示員工信息
    加薪
   寫測試類
       創建對象 ,調用方法


創建對象的過程,對象的內存結構圖


方法
   方法的基本結構
        public static void main(String[] args) {
            方法體
        }

       a.訪問修飾符 
        public --公有的--只要不出工程都可以訪問
        protected --保護類型 -- 子類和同一個包內可以訪問  
        默認 -- 同一個包內可以訪問
        private --私有的 --只有本類可以訪問

       b.可選修飾符 staitc final native
   
       c.返回值類型

       d.方法名
     
       e.形參列表
    
       f.方法體

      方法的作用:封裝重用的代碼,完成特定業務邏輯功能
    
   實參與形參
      實參--實際參數---調用環境中的參數
      形參--形式參數---方法原型中聲明的參數
  java中調用方法就是實參向形參賦值過程


  繼承
   什麼是繼承?
     public class Father{  } //父類 超類 基類
     public class Child extends Father{//子類 派生類

     }
   子類繼承父類所有的非私有成員,構造方法也不能繼承,static修飾的方法不能繼承

   繼承中的構造方法
       在調用子類構造方法時,必須首先調用父類的構造方法(編譯器強制的)
        ,目的是初始化父類的成員變量


構造方法
   一類特殊的方法
   public Dog(...){

    }
   構造方法與類同名,沒返回值,但也不用void修飾
   構造方法的作用
   Dog dog = new Dog(...);// new 構造方法(...)
   創建對象,開闢對象的內存空間,初始化成員變量


多態(同名方法,完成不同的業務功能,展現出多種形態)
(重載與重寫) 
   靜態多態
        方法的重載
        在同一個類中,方法名相同,形參列表不同的兩個方法
        所謂形參列表不同:
           a.參數的個數不同
           b.參數類型不同
           c.參數類型的順序不同
    在程序的編譯器通過參數列表就可以確定要調用那個方法

   動態多態
   方法的重寫
       前提條件:繼承關係
       在子類中創建一個與父類方法同名的方法
       這兩個方法應該有如下特點:
         方法名相同,形參列表相同,返回值類型相同(兼容)
         子類方法的訪問修飾訪問>=父類方法的訪問修飾範圍
   向上造型
      父類的引用指向子類的實例
      Aniaml dog = new Dog();
      Animal cat = new Cat();
         dog.eat(); cat.eat();
     dog cat 稱爲上轉型對象,上轉型對象調用的子類重寫父類的方法
    而且這種調用時程序運行的時候決定的,所以稱爲動態多態


static 與 final 
   static稱爲靜態的,用static修飾的成員屬於類,而不是對象
  靜態成員變量 
     
  靜態方法
      static修飾的方法只能調用本類靜態的成員(編譯器強制檢查)

  案例:統計小狗個數
  內存結構圖

  final 修飾變量,變量一旦初始化就不可修改
  基本類型:值不可改變
  引用類型:對象不可改變,但對象的內容可以修改

  final修飾方法,這個方法不能被重寫
  final修飾類,這個類不能被繼承


抽象類與接口
  什麼是抽象類?
  有一些類沒有必要實例化,實例化沒有意義,它可以封裝通用
  的業務代碼
  Animal -- 沒有必要實例化
  Dog
  Cat
  Fish ...

   抽象類用abstract修飾
   抽象方法:用abstract修飾的方法,只有方法的聲明,沒有方法的實現
   在子類中實現抽象方法

  一個子類繼承抽象類,就必須實現抽象中中聲明的所有抽象方法,否則
  這個子類也必須聲明爲抽象類

  案例:寫Cat類,繼承Animal,測試

  側重點在代碼重用
  什麼是接口?
   更加純粹的抽象類,將抽象類中非抽象的因素都剝離了,專注於
   頂層設計

   接口中只能由兩種成員
     a. public abstract 修飾的方法
     b. public static final 修飾的變量 -->常量
 側重點在設計對象

     一個類只能繼承一個一般類或者抽象類
    但是一個類可以實現多個接口(變相的實現了多繼承)
    接口可以繼承接口,而且是多繼承
     

package demo02;

public class Employee {
	 //私有的成員變量
     private int id;
     private String name;
     private String sex;
     private int age;
     private float salary;
     private String dept;
     //空參的構造方法
     public Employee() {
    	 super();
    	 // TODO Auto-generated constructor stub
     }

	//有參的構造方法
     public Employee(int id, String name, String sex, int age, float salary, String dept) {
    	 super();
    	 this.id = id;
    	 this.name = name;
    	 this.sex = sex;
    	 this.age = age;
    	 this.salary = salary;
    	 this.dept = dept;
     }

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public float getSalary() {
		return salary;
	}
	public void setSalary(float salary) {
		this.salary = salary;
	}
	public String getDept() {
		return dept;
	}
	public void setDept(String dept) {
		this.dept = dept;
	}
     
	//展示員工信息
	public void printInfo(){
		  System.out.println(id+","+name+","+sex+","+age+","+salary+","+dept);
	}
     
	//加薪
	public void addSalary(float salary){
		 this.salary += salary;
	}
     
}
package demo02;

public class TestEmp {
    public static void main(String[] args) {
		 //創建員工對象
    	Employee e = new Employee(1, "jack", "男", 23, 12000, "系統開發部");
    	e.printInfo();
    	//加薪
    	e.addSalary(500);
    	e.printInfo();
	}
}
package demo02;

public class Student {
   //類的成員
	//成員變量 -- 對象的特徵
    private int id;//學生編號
    private String name;//姓名
    private String sex;//性別
    private int age;//年齡
    
    //空參的構造方法    
    public Student() {
    }
    

    //有參的構造方法
	public Student(int id, String name, String sex, int age) {
		this.id = id;
		this.name = name;
		this.sex = sex;
		this.age = age;
	}

    //set get 方法
	//get -- 讀方法
	public int  getId(){ // id屬性
		 return this.id;
	}
	
	//set --寫方法
	public void setId(int id){
		  this.id = id;
	}
	
	

	public String getName() {
		return name;
	}


	public void setName(String name) {
		this.name = name;
	}


	public String getSex() {
		return sex;
	}


	public void setSex(String sex) {
		this.sex = sex;
	}


	public int getAge() {
		return age;
	}


	public void setAge(int age) {
		this.age = age;
	}


	//成員方法 -- 對象的行爲
    //打印學生的基本信息
    public void printInfo(){
    	 System.out.println(id+","+name+","+sex+","+age);
    }


}
package demo02;

public class TestStudent {
      public static void main(String[] args) {
		   //創建學生對象
    	 // Student stu = new Student();
    	  Student stu = new Student(1, "tom", "男", 22);
    	  stu.setName("張三");
    	  System.out.println(stu.getName());
    	  stu.printInfo();
	}
}
package demo02;

public class Demo01 {
    public static void main(String[] args) {
		//主方法是調用環境
    	String msg = "hello world";
    	printInfo(msg);//實際參數
	}
    
    public static void printInfo(String msg){//形式參數
    	  System.out.println(msg);
    }
}
package demo02;

public class Demo02 {
	/**
	 *  方法的重載
	 * @param args
	 */
    public static void main(String[] args) {
		   int num = add(1,2);
		   System.out.println(num);
		   num = add(1,2,3);
		   System.out.println(num);
		   float fnum = add(1.2f,3.6f);
	       
	}
    
    //加法 
    //兩個整數相加
    public static int add(int a,int b){
    	  return a + b;
    }
    
    public static int add(int a,int b,int c){
    	return a + b +c;
    }
    
    public static float add(float a,float b){
  	  return a + b;
  }
    
    public static String add(int a,String b){
  	  return a + b;
  }
    
    public static String add(String a,int b){
    	  return a + b;
    }
    
}
package demo02;

public class Animal {
	private String name;
	private int age;

	public Animal() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Animal(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

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

	   public void eat() {
		System.out.println(this.name + "ÔÚ³Ô¶«Î÷");
	}
}
package demo02;

public class Cat extends Animal{

	  @Override
	public void eat() {
         System.out.println(getName()+"正在喝魚湯");
	}
}
package demo02;

public class Dog extends Animal{
    private  static int count;
	public Dog() {
       count++;
	}


   @Override
	public  void eat() {
		  System.out.println("µÚ"+count+"Ìõ¹·"+getName()+"ÔڿйÇÍ·");
	}
}
package demo02;

public class TestDog {
    public static void main(String[] args) {
		  Dog dog = new Dog();
		  dog.setName("旺財");
		  dog.setAge(1);
		  dog.eat();
		  
		  Cat cat = new Cat();
		  cat.setName("花花");
		  cat.setAge(2);
		  cat.eat();
		  System.out.println("---------------------");
		  //向上造型
		  Animal dog2 = new Dog();
		  dog2.setName("小黑");
		  dog2.setAge(3);
		  //dog2.eat();
		  
		  Animal cat2 = new Cat();
		  cat2.setName("小花花");
		  cat2.setAge(1);
		  //cat2.eat();
		  eat(cat2);
		  
	}
    
    //設計一個方法適合所有的調用環境
    public static void  eat(Animal an){
    	  an.eat();
    }
}
package demo02;

public class CountDog {
    public static void main(String[] args) {
		 //統計創建的小狗的數量
    	Dog dog1 = new Dog();
    	dog1.setName("旺財");
    	dog1.setAge(1);
    	dog1.eat();
    	Dog dog2 = new Dog();
    	dog2.setName("小黑");
    	dog2.setAge(2);
    	dog2.eat();
	}
}

 

 

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章