歡迎來到Linux教程網
Linux教程網
Linux教程網
Linux教程網
您现在的位置: Linux教程網 >> UnixLinux >  >> Linux編程 >> Linux編程

Java面向對象基本特征

1、封裝性
    一個對象和外界的聯系應當通過一個統一的接口,應當公開的公開,應當隱藏的隱藏。
    屬性的封裝:Java中類的屬性的訪問權限的默認值是default,要想隱藏該屬性或方法,就可以加private(私有)修飾符,來限制只能夠在類的內部進行訪問。對於類中的私有屬性,要對其給出一對方法(getXxx(),setXxx())訪問私有屬性,保證對私有屬性的操作的安全性。
    方法的封裝:對於方法的封裝,該公開的公開,該隱藏的隱藏。方法公開的是方法的聲明(定義),即(只須知道參數和返回值就可以調用該方法),隱藏方法的實現會使實現的改變對架構的影響最小化。
public class TestDemo {
    public static void main(String[] args) {
        Person person=new Person();
        person.tell();
        person.setAge(-20);
        person.setName("張三");
        person.tell();
    }
}
class Person{
    private int age;
    private String name;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if(age>0&&age<150){
            this.age = age;
        }
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    void tell(){
        System.out.println("姓名:"+name+";年齡:"+age);
    }
}

備注:
(1)Java匿名對象:只需要使用一次的場所。例如:new Person().tell();
     
(2)Java構造方法:構造方法名稱必須與類名一致,沒有返回指,可以重載,主要為類中的屬性初始化。

     
(3)值傳遞的數據類型:八種基本數據類型和String(String也是傳遞的地址,只是String對象和其他對象是不同的,String是final的,所以String對象值是不能被改變的,值改變就會產生新對象。那麼StringBuffer就可以了,但只是改變其內容,不能改變外部變量所指向的內存地址)。
引用傳遞的數據類型:除String以外的所有復合數據類型,包括數組、類和接口。
123456789101112131415161718192021222324252627282930 public class TestRef4 {
public static void main(String args[])
  {
    int val=10;;
    StringBuffer str1, str2;   
    str1 = new StringBuffer("apples");
    str2 = new StringBuffer("pears");
     
    System.out.println("val:" + val);
    System.out.println("str1 is " + str1);
    System.out.println("str2 is " + str2); 
    System.out.println("...............................");
     
    modify(val, str1, str2); 
    System.out.println("val is " + val);
    System.out.println("str1 is " + str1);
    System.out.println("str2 is " + str2);
  }
 
  public static void modify(int a, StringBuffer r1,StringBuffer r2)
  {     
      a = 0;
      r1 = null;       
      r2.append(" taste good");
      System.out.println("a is " + a);
      System.out.println("r1 is " + r1);
      System.out.println("r2 is " + r2);
      System.out.println("...............................");
  }
}

輸出結果為:
val:10
str1 is apples
str2 is pears
...............................
a is 0
r1 is null
r2 is pears taste good
...............................
val is 10
str1 is apples
str2 is pears taste good

(4)this關鍵字:表示類中的屬性或方法;調用類中的構造方法,例如:this();表示當前對象。


(5)static關鍵字:static申明屬性為全局屬性;static申明方法直接通過類名調用;使用static方法時,只能訪問static申明的屬性和方法,而非static申明的屬性和方法時不能訪問。

2、繼承性

    在程序中,使用extends關鍵字讓一個類繼承另一個類,繼承的類為子類,被繼承的類為父類,子類會自動繼承父類所有的方法和屬性
    class 子類 extends 父類{}

示例1:
public class ExtendsDemo1 {
    public static void main(String[] args) {
        Student student=new Student();
        student.setAge(15);
        student.setName("張三");
        student.setScore(90);
        student.tell();
        System.out.println("..............................");
        System.out.println("name:"+student.getName()+";age:"+student.getAge()+";score:"+student.getScore());
    }
}
 
class Person{
    private int age;
    private String name;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
 
class Student extends Person{
    //private int age;
    //private String name;
        private int score;
      //public int getAge() {
    //return age;
    //}
    //public void setAge(int age) {
    //this.age = age;
    //}
    //public String getName() {
    //return name;
    //}
    //public void setName(String name) {
    //this.name = name;
        //}
    public int getScore() {
        return score;
    }
    public void setScore(int score) {
        this.score = score;
    }
    public void tell(){
        System.out.println("name:"+getName()+";age:"+getAge()+";score:"+getScore());
    }
}

輸出結果:
name:張三;age:15;score:90
..............................
name:張三;age:15;score:90


2.1 在Java中只允許單繼承(一個子類只允許有一個父類),子類不能直接訪問父類的私有成員
示例2:

 public class ExtendsDemo2 {
 public static void main(String[] args){
 PetWorker petWorker=new PetWorker();
 petWorker.setAge(20);
 petWorker.setWork("teacher");
 petWorker.tell();
 }
}
/**
 * 創建類People
 * @author Admin
 *
 */
class People{
    private int age;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
/**
 * 創建Worker類,單繼承People類
 * @author Admin
 *
 */
class Worker extends People{
    private String work;
    public String getWork() {
        return work;
    }
    public void setWork(String work) {
        this.work = work;
    }
}
/**
 * 創建PetWorker類,單繼承Worker類
 * @author Admin
 *
 */
class PetWorker extends Worker{
    public void tell() {
        System.out.println("age:"+getAge()+";work:"+getWork());
    }
}

輸出結果:
age:20;work:teacher


2.2 Java方法重寫
  定義:方法名稱相同,返回值類型相同,參數也相同,其實質就是子類定義了和父類同名的方法。
  重寫限制:被子類重寫的方法不能擁有比父類方法更嚴格的訪問權限。private<default<public
  子類調用父類中的方法:super.方法名(參數)
public class ExtendsDemo1 {
    public static void main(String[] args) {   
    B b=new B();
    b.tell();
    }
}
 
class A{
    public void tell(){
      System.out.println("父類中的tell方法");
    }
}
 
class B extends A{
    public void tell() {
    super.tell();
    System.out.println("我重寫了tell方法");
    }
    void say(){
    super.tell();
    }
}

輸出結果:
  父類中的tell方法
  我重寫了tell方法
  父類中的tell方法

方法重載與方法重寫區別   方法重載(Overloading)
方法重寫(Override) 定義 方法名稱相同,參數的類型或個數不同 方法名稱、參數類型、返回值類型全部相同 權限要求 對權限沒有要求 被重寫的方法不能擁有比父類更加嚴格的權限 范圍 發生在一個類中 發生在繼承中

2.3 抽象類與接口
  final能申明類、方法和屬性,使用final申明的類不能被繼承,使用final申明的方法不能被重寫,使用final申明的變量變成常量(定義時要賦值),常量是不可以修改的。
  抽象類:包含一個抽象方法的類就是抽象類。
定義:
abstract  class ClassName{
    屬性
    方法
    抽象方法
}
(1)抽象方法:申明而未實現的方法,抽象方法必須使用abstract關鍵字申明,只有方法名和參數,沒有方法體。
(2)抽象類被子類繼承,子類(若不是抽象類)必須重寫抽象類中的所有抽象方法。
(3)抽象類不能實例化,要通過其子類進行實例化。
public class AbstractClassDemo1 {
    public static void main(String[] args) {
        StuClass stuClass=new StuClass();
        stuClass.tell();
        stuClass.say();
    }
}
 
abstract class AbsClass{
    int age;
    public void tell(){
        System.out.println("父類中的tell方法");
    }
    public abstract void say();
}
 
class StuClass extends AbsClass{
    @Override
    public void say() {
        System.out.println("子類實現父類抽象類中的say抽象方法");
    }
}

 

  接口可以理解為一種特殊的類(沒有構造方法),裡面全部是由全局常量和公共的抽象方法組成,接口的實現必須通過子類,使用關鍵字implements,而且子類可以多實現接口。一個接口不能實現(implements)另一個接口,但它可以繼承多個其它的接口。接口定義如下:
[修飾符] interface 接口名 [extends 父接口名列表]{
    [public] [static] [final] 全局常量;
    [public] [abstract] 抽象方法;
}
樣例:

public abstract class InterfaceDemo1 {
    public static void main(String[] args) {
        InterfaceClass interfaceClass=new InterfaceClass();
        interfaceClass.print(1.0f);
    }
}
 
class InterfaceClass implements CalInterface1,CalInterface2{
    @Override
    public void print(float r) {
        System.out.println("半徑為"+r+"的圓面積:"+getArea(r)+",周長:"+getCircumference(r));
    }
    @Override
    public float getArea(float r) {
        float area=PI*r*r;
    return area;
    }
    @Override
    public float getCircumference(float r) {
        float circumference=2*PI*r; 
    return circumference; 
    }
}
//定義接口CalInterface1
interface CalInterface1 
{
    float PI=3.14159f;//PI默認為public static final類型
    float getArea(float r);//方法getArea()默認為public abstract類型,注意抽象方法沒有方法體 
    public abstract float getCircumference(float r);//計算面積
}
//定義接口CalInterface2
interface CalInterface2
{   
    void print(float r);//打印輸出結果
}
//定義接口CalInterface3,繼承接口CalInterface1和CalInterface2
interface CalInterface3 extends CalInterface1,CalInterface2{
     
}

輸出結果:
    半徑為1.0的圓面積:3.14159,周長:6.28318


抽象類和接口的對比

參數
抽象類 接口 實現 子類使用extends關鍵字來繼承抽象類。如果子類不是抽象類的話,它需要提供抽象類中所有聲明的方法的實現。 子類使用關鍵字implements來實現接口。 構造器 可以有構造器 無構造器 修飾符 抽象方法可以有public、protected和default這些修飾符 接口方法默認修飾符是public。你不可以使用其它修飾符。 main方法 抽象方法可以有main方法並且我們可以運行它 沒有main方法 多繼承 抽象類可以繼承一個類和實現多個接口 接口只可以繼承一個或多個其它接口 速度 要快些 慢些

(1)如果你擁有一些方法並且想讓它們中的一些有默認實現,那麼使用抽象類。

(2)如果你想實現多重繼承,那麼你必須使用接口。由於Java不支持多繼承,子類不能夠繼承多個類,但可以實現多個接口。因此你就可以使用接口來解決它。

(3)如果基本功能在不斷改變,那麼就需要使用抽象類。如果不斷改變基本功能並且使用接口,那麼就需要改變所有實現了該接口的類。

 

Copyright © Linux教程網 All Rights Reserved