java day05之面向物件
阿新 • • 發佈：2019-01-11
學習面向物件的三條主線
1.java類及類的成員
2.面向物件的三大特徵
3.其他關鍵字
面向物件（OOP）與面向過程
（1）二者都是一種思想，面向物件是相對於面向過程而言的。面向過程，強調的是功能行為。面向物件，將功能封裝進物件，強調具備了功能的物件
（2）面向物件更加強調運用人類在日常的思維邏輯中採用的思想方法與原則，如抽象、分類、繼承、聚合、多型等
面向物件的三大特徵
1）封裝（Encapsulation）
2）繼承（Inheritance）
3) 多型（Polymorphism）
理解和區分面向物件和麵向過程
package com.huake.java; /* 理解一：人開門 面向過程:人 開啟 門 面向物件： 人{ 開啟(門){ 門.開開() } 門{ 開開(){ } } 理解二：人 把大象裝進冰箱 面向過程：1）開啟冰箱 2）把大象放進去 3）關閉冰箱門 面向物件： 人{ 開啟(冰箱){ 冰箱.開開()} 操作(大象){ 大象.進入(冰箱) } 關閉(冰箱){ 冰箱.關閉() } } 大象{ 進入(冰箱){ } } 冰箱{ 開啟(){} 關閉(){} } */ public class TestOOP { }
面向物件的思想概述
1）完成需求時：
①先去找具有所需功能的物件來用。
②如果該物件不存在，那麼建立一個具有所需功能的物件
③這樣簡化開發並提高複用
2）類（class）和物件（object）是面向物件的核心概念
①類是對一類事物的描述，是抽象的。概念上的定義
②物件是實際存在的該類事物的每個個體，因而也稱例項（instance）
3）萬事萬物皆物件
屬性：對應類中的成員變數
行為：對應類中的成員方法，也就是函式
設計類與建立類
package com.huake.java; /* * 面向物件思想的落地法則 * 1.設計類，並設計類的成員（成員變數和成員方法） * 2.通過類，來建立類的物件（也叫作類的例項化） * 3.通過“物件.屬性”或“物件.方法”來呼叫，完成相應的功能 * * 建立的多個物件，各自擁有一套類的屬性， * 當對其中一個物件的屬性進行修改時 ， * 不會影響到其他物件的屬性值 * */ public class Zoo { public static void main(String[] args) { //1.類的例項化:如下的a1就是一個實實在在的物件 Animal a1=new Animal(); a1.name="huahua"; a1.age=2; System.out.println("name:"+ a1.name+" age:"+a1.age); //通過物件呼叫方法 a1.eat(); a1.sleep(); //再建立一個類的物件 Animal a2=new Animal(); System.out.println("name:"+ a2.name+" age:"+a2.age);//null 0 } } class Animal{ //1.屬性 String name; int age; //2.方法 public void eat(){ System.out.println("eat"); } public void sleep(){ System.out.println("sleep"); } public String getName(){ return name; } public void setName(String n){ name=n; } }
設計類的成員變數及方法
package com.huake.java; /* * 1.面向物件的程式設計關注於類的設計 * 2.設計類實際上就是設計類的成員 * 3.基本的類的成員：屬性（成員變數或Field） & 方法（Method） */ import java.util.Scanner; public class TestPerson { public static void main(String[] args) { Person p1=new Person(); p1.info(); p1.name="dabai"; p1.age=21; p1.sex=true; //true代表男 p1.info(); p1.setName("xiaohei");//相當於p1.name="xiaohei" p1.info(); Person p2=p1; System.out.println("p1:"+p1); System.out.println("p2:"+p2); p2.info(); p2=new Person(); System.out.println("p2:"+p2); p2.info(); //例項化Scanner類的物件，通過此物件.nextXX（）呼叫，完成相應的功能 Scanner s=new Scanner(System.in); int i=s.nextInt(); } } //類 是抽象的 class Person{ //1.屬性：Field String name; int age; boolean sex; //2.方法 public void eat(){ System.out.println("人吃飯"); } public void sleep(){ System.out.println("人睡覺"); } public String getName(){ return name; } //給屬性name賦值 public void setName(String n){ name=n; } public void info(){ eat(); sleep(); System.out.println("name:" + name + " age:" + age + " sex:" + sex); } }
類的訪問機制
1）在一個類中的訪問機制：類中的方法可以直接訪問類中的成員變數。（例外：static方法訪問非static，編譯不通過）
2）在不同類中的訪問機制：先建立要訪問類的物件，再用物件訪問類中定義的成員。
案例一：建立一個Person類
package com.huake.exer;
/*
* 要求：（1）建立Person類的物件，設定該物件的name、age和sex屬性，呼叫study方法，
* 輸出字串“studying”，呼叫showAge()方法顯示age值，呼叫addAge()方法給物件的age屬性
* 值增加2歲。
* （2）建立第二個物件，執行上述操作，體會同一個類的不同物件之間的聯絡
* */
//測試類
public class TestPerson {
public static void main(String[] args) {
Person p=new Person();
p.study();
p.showAge();
p.addAge(2);
p.showAge();
Person p1=new Person();
p1.showAge();
}
}
class Person{
//1.屬性
String name;
int age;
int sex;
//2.方法
public void study(){
System.out.println("studying");
}
public void showAge(){
System.out.println(age); //列印呼叫showAge()方法的物件的age屬性
}
//給呼叫此方法的物件的age屬性增加i歲，並返回新的age
public int addAge(int i){
age+=i;
return age;
}
}
案例二：利用面向物件 計算圓的面積
package com.huake.exer;
//利用面向物件的程式設計方法，設計類Circle計算圓的面積
public class TestCircle {
public static void main(String[] args) {
Circle c=new Circle();
//c.findArea(2.0);
c.r=2.0;
double area=c.findArea();
System.out.println(area);
c.setR(4.5);
System.out.println(c.findArea());
}
}
class Circle{
double r; //半徑
//提供方法用於獲取圓的面積
// public void findArea(double r){
// //此處的r為呼叫findArea()方法的物件的屬性r
// System.out.println(3.14*r*r);
// }
public double findArea(){
return r * r * 3.14;
}
public double getR(){
return r;
}
public void setR(double ra){
r=ra;
}
}
案例三：使用面向物件程式設計陣列最大值最小值遍歷輸出反轉
package com.huake.java;
public class ArrayUtil {
//求陣列的最大值
public int getMax(int [] arr){
int max=arr[0];
for(int i=0;i<arr.length;i++){
if(max<arr[i]){
max=arr[i];
}
}
return max;
}
//求陣列的最小值
public int getMin(int [] arr){
int min=arr[0];
for(int i=0;i<arr.length;i++){
if(min>arr[i]){
min=arr[i];
}
}
return min;
}
//遍歷陣列元素
public void printArray(int [] arr){
System.out.print("[");
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
System.out.print("]");
}
//求陣列的平均數
public int avg(int []arr){
int sum=0;
for(int i=0;i<arr.length;i++){
sum+=arr[i];
}
return sum/arr.length;
}
//求陣列的總和
public int getSum(int [] arr){
int sum=0;
for(int i=0;i<arr.length;i++){
sum+=arr[i];
}
return sum;
}
//陣列的反轉
public int [] reverse(int [] arr){
for(int i=0;i<arr.length/2;i++){
int temp=arr[i];
arr[i]=arr[arr.length-1-i];
arr[arr.length-1-i]=temp;
}
return arr;
}
//陣列的複製
public int [] copy(int [] arr){
int [] arr1=new int [arr.length];
for(int i=0;i<arr.length;i++){
arr1[i]=arr[i];
}
return arr1;
}
//對 陣列進行排序
public void sort(int [] arr){
for(int i=0;i<arr.length-1;i++){
for(int j=0;j<arr.length-i-1;j++){
if(arr[j]>arr[j+1]){
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
}
package com.huake.java;
public class TestArray {
public static void main(String[] args) {
int [] arr=new int []{12,4,76,0,-98,56,37,100};
ArrayUtil au=new ArrayUtil();
int max=au.getMax(arr);
System.out.println("最大值為："+max);
int avg=au.avg(arr);
System.out.println("平均值為："+avg);
System.out.println("陣列本身如下：");
au.printArray(arr);
System.out.println();
System.out.println("反轉陣列如下：");
au.reverse(arr);
au.printArray(arr);
System.out.println();
System.out.println("對陣列進行排序：");
au.sort(arr);
au.printArray(arr);
}
}
過載的概念：
在同一個類中，允許存在一個以上的同名方法，只要他們的引數個數或者引數型別不同即可
過載的特點：
與返回值型別無關，只看引數列表，且引數列表必須不同。（引數個數和引數型別）。呼叫時，根據方法引數列表的不同來區別。
過載例項
package com.huake.java;
/*
* 方法的過載（overload）
* 要求：1.在同一個類中 2.方法名必須相同（getSum）
* 3.方法的引數列表不同（引數的個數不同，引數個數相同但是型別不同）
* 補充:方法的過載與方法的返回值型別沒有關係*/
public class TestOverload {
}
class Overload{
//定義兩個int型遍歷的和
public int getSum(int i,int j){
return i+j;
}
//定義三個遍歷的和
public int getSum(int i,int j,int k){
return i+j+k;
}
//不能與其他幾個方法構成過載
// public int getSum1(int i,int j,int k){
// return i+j+k;
// }
// public void getSum(int i,int j,int k){
// System.out.println(i+j+k);
// }
//定義兩個double型別的資料的和
public double getSum(double d1,double d2){
return d1+d2;
}
//定義三個double型別的資料的和
public void getSum(double d1,double d2,double d3){
System.out.println(d1+d2+d3);
}
public void method1(int i,String str){
}
public void method1(String str1,int j){
}
}
案例：
package com.huake.exer;
/*題目一
* 編寫程式，定義三個過載方法並呼叫，方法名為mOL
* 三個方法分別接收一個int引數，兩個int引數，一個字串引數，分別執行平方運算並輸出結果
* 相乘並輸出結果，輸出字串資訊
* 在主類的main()方法中分別用引數區別呼叫三個方法
* 題目二：
* 定義三個過載方法max（），第一個方法求兩個int值中的最大值
* 第二個方法求兩個double中的最大值
* 第三個方法求三個double中的最大值，並分別呼叫三個方法*/
public class TestOverload {
public static void main(String[] args) {
TestOverload t=new TestOverload();
t.mOL(12);
t.mOL("www.huake.com");
System.out.println(t.max(12,13));
System.out.println(t.max(12.1,14.3));
}
public double max(double d1,double d2,double d3){
return (max(d1,d2)>d3)?max(d1,d2):d3;
}
public double max(double d1,double d2){
return (d1>d2)?d1:d2;
}
public int max(int i,int j){
return (i>j)?i:j;
}
//以上三個方法構成過載
//以下三個方法構成過載
public void mOL(int i){
System.out.println(i*i);
}
public void mOL(int i,int j){
System.out.println(i*j);
}
public void mOL(String str){
System.out.println(str);
}
}