JAvaの4つの基本的な特性--カプセル化継承多態抽象

明日に間に合ってメーデーの連休になります.ここ数日、オリジナルの文章をいくつか書いて、みんなで勉強するつもりです.
まず今日はじっくりお話ししますが、javaのいくつかの特性は何なのでしょうか.いったいどうやって使いますか.きっといくつかの白がこれに対して少し悩むことができることを信じて、大丈夫で、誰がまだその時から来たのではありません!次に私は一歩一歩深く潜って私の見方を話して、次は私の言う内容です.
1.全体概括
2.概念の理解
3.コード例と分析
4.個人の心得まとめ
1.全体概括

sequenceDiagram
  ->>  : java       
  ->>  : java       

2.概念の理解

[1]パッケージ:

-オブジェクト向けプログラミング方法では、パッケージ(英語:Encapsulation)とは、抽象的な関数インタフェースの実装の詳細を部分的にパッケージ化し、隠す方法を指す.
カプセル化は、クラスのコードおよびデータが外部クラスによって定義されたコードにランダムにアクセスすることを防止する保護バリアと見なすことができる.
クラスのコードとデータにアクセスするには、厳格なインタフェースで制御する必要があります.
パッケージの最も主要な機能は、私たちのコードを呼び出すプログラムのセグメントを変更することなく、自分の実装コードを変更できることです.
適切なパッケージは、プログラムコードの理解とメンテナンスを容易にし、コードの安全性を強化することができます.

           ，           ，       ，

  ：      QQ       ，                    

，                             ，          

         QQ           ，     

   ，        ，              

           QQ       ，        ，          

               ：             ——CPU               ... 
    
                         ，                     
    
                         。(                 ）

[2]継承

継承」(Inheritance)、

継承とは、ある対度象が別のオブジェクトの属性と方法を直接使用することです.実際、私たちが出会った多くのエンティティには継承の意味があります.例えば、自動車を一つの実体と見なせば、トラック、バスなど、複数の実答体に分けることができる.これらの版のサブエンティティはすべて自動車の特性を持っていて、そのため、自動車はそれらの“父”で、これらのサブエンティティは自動車の“子供”です(しかし子供も自分で新しく生んだ特徴があります).子は親の特殊化、つまり子の実例は親の実例に違いないが、逆に成立するとは限らない.

             ：   ，      ，                 

           (         )，                   ，   ！                      (          )，             ，        

[3]マルチステート

-概念:同じ操作が異なるオブジェクトに作用し、異なる解釈があり、異なる実行結果を生成することができます.これが多態性です.簡単に言えば、親クラスの参照で子クラスのオブジェクト(変数)を指します.
理由:パッケージは実装の詳細を隠し、コードをモジュール化できることを知っています.
継承は既存のコードモジュール(クラス)を拡張することができる.コードの再利用を目的としています.マルチステートはコードの多重性に加えて、プロジェクトにおける密接なカップリングの問題を解決し、プログラムの拡張性を高めることができる.
結合度はモジュールモジュール間、コードコード間の関連度を話し、システムの分析を通じて彼を1つのサブモジュールに分解し、サブモジュールは安定したインタフェースを提供し、システム結合度を低下させる目的を達成し、モジュールモジュール間でできるだけモジュールインタフェースを使用して他のモジュールのメンバー変数を勝手に引用するのではなく、訪問する.
2つのメリットがあります.1.アプリケーションは、派生クラスごとに機能呼び出しを記述する必要はありません.抽象ベースクラスを処理するだけです.プログラムの多重化を大幅に向上させる.//継承2.派生クラスの機能は、ベースクラスのメソッドまたは参照変数によって呼び出され、後方互換性と呼ばれ、拡張性とメンテナンス性を向上させることができます.//マルチステートの真の役割は,メソッドのパラメータとメソッドの戻りタイプで使用できる.(子変数は親の変数を参照)

[4]抽象:

1つのオブジェクトをそれぞれの属性を解析し,表現の代わりにする手法である.
吸うのは引き離すことです.象を表す.表示される部分

     。           ，         

                    ，           。

             ，        ，             。

     ，10  ，    ，     ，    ，  。                。      10  ，      ，             。

プログラミングでオブジェクトを抽象化するのは有用な方法であり,退屈なデータを単一度のオブジェクトに対応させることができ,理解しやすく,プログラミングも容易である.

           。

     ，      ，    ，     ，    。           

3.コード例と分析

[1]マルチステート

public class Main {
    public static void main(String[] args) {
        //         、                    :
        Income[] incomes = new Income[] {
            new Income(3000),
            new Salary(7500),
            new StateCouncilSpecialAllowance(15000)
        };
        System.out.println(totalTax(incomes));
    }

    public static double totalTax(Income... incomes) {
        double total = 0;
        for (Income income: incomes) {
            total = total + income.getTax();
        }
        return total;
    }
}

class Income {
    protected double income;
//    
    public Income(double income) {
        this.income = income;
    }
//      
    public double getTax() {
        return income * 0.1; //   10%
    }
}
//  Salary    Income
class Salary extends Income {
	//    
    public Salary(double income) {
    	//super      Salary      
        super(income);
    }

    @Override
    public double getTax() {
        if (income <= 5000) {
            return 0;
        }
        return (income - 5000) * 0.2;
    }
}

class StateCouncilSpecialAllowance extends Income {
    public StateCouncilSpecialAllowance(double income) {
        super(income);
    }

    @Override
    public double getTax() {
        return 0;
    }
}

  ：800.0

totalTax()を観察する方法:マルチステートを利用して、totalTax()はincomeと付き合うだけで、State CouncilSpecialAllowanceとSalaryの存在を全く知る必要はありません.得られた税金を完全に計算することができます.原稿料の収入を増やすには、再incomeから派生し、getTaxメソッド()を正しくカバーするだけでいいです.新しいタイプをgetTax()に転送すればいいので、コードを再修正する必要はありません.
マルチステートがどれほど強力な機能であるかは、親ベースのコードを変更する必要がなく、より多くのタイプのサブクラスを追加して機能拡張を実現できるようにすることです.

[2]継承

public class Bike {
	int speed;
	int brand;
	int colornum;
	//    
	Bike(){
		System.out.println(" call bike constructor");
	}
	public void speedUp() {
		speed = 0;
		System.out.println(" too slow");
	}
	public void presshorn() {
		System.out.println(" I am riding the bike");
	}
}

public class SpeedBike extends Bike{
	/**
	 * super              
	 */
	SpeedBike(){//       
		super();
		super.colornum=12;//        
		super.presshorn();
		System.out.println("call bike construction");	
	}
	public void ride() {
		System.out.println("I am riding the bike");
	}
	/**
	 * super         
	 */
	public void speedUp() {
		super.speedUp();
		speed+=10;
		System.out.println("so fasyt! ," + " my speed is " + speed + " now");
	}
}

public class DemoBike{
	public static void main(String[] args) {
		SpeedBike aride = new SpeedBike();
				aride.presshorn();
				aride.speedUp();
				aride.ride();
	}
}

  ：
call bike constructor
 I am riding the bike
call bike construction
 I am riding the bike
 too slow
so fasyt! , my speed is 10 now（                  )
I am riding the bike

[3]抽象classがメソッドを定義しているが、具体的な実行コードがない場合、このメソッドは抽象メソッドであり、抽象メソッドはabstractで実現されるが、抽象メソッドを実行できないため、このクラスは抽象クラス

に申請しなければならない.
たとえば、Personクラスは抽象メソッドrun()を定義し、サブクラスStudioを実装する際にrun()メソッドを上書きする必要があります.

public class Main {

	public static void main(String[] args) {
		Person p= new Student();
		p.run();
	}
}
abstract class  Person() {
	public abstract void run();
}
class Student extends Person{
	@overriding
	public void run() {
		System.out.println("Student . run");
	}
}

[4]パッケージ

package com.fengzhuang;
class Car{
    private String name;//    ，  
    private String color;//    ，  
    private String size;//    ,   
    //  String       ，  return    
    public String getName(){
        return name;
    }
    public String getColor(){
        return color;
    }
    public String getSize(){
        return size;
    }
    //           ，   this
    public void setName(String name){
        this.name=name;
    }
    public void setColor(String color){
    this.color=color;
    }
    public void setSize(String size){
    this.size=size;
    }
}

package com.fengzhuang;
public class Test{
    public static void main(String[] args){
        Car b=new Car();//     
        b.setName("  ");//  
        b.setColor("  ");
        b.setSize("  ");
        //              。
        String name=b.getName();//  
        String color=b.getColor();
        String size=b.getSize();
        //      
        System.out.println(name+":"+color+":"+size);
    }
}

  :
  :  :  

解析:声名変数の場合、私的変数としていくつか設定されているので、アクセスしたい場合はsetというセットアップでのみアクセスできます.
抽象とインタフェースは実際にプロジェクトを開発するのによく使われていますね.身につけた知識を開発に柔軟に応用するために、以下は自分が実際にプロジェクトを書いたときに出会った問題で、あなたたちに役に立つことを望んでいます.
抽象クラス:共通の属性方法を抽象化し、一つの場所(彼らが実現したコードは同じ)に統一し、メンテナンスを容易にすることを強調します.(つまり上記のようなオブジェクト向けの特徴における継承)
インタフェース:つまり抽象的な行為、例えば:1人の犬、彼の色、白、黄色など、犬はインタフェースと見なすことができて、その色などは抽象的に方法を作ることができます.複数のオブジェクトが同じ動作を有するが、動作の具体的な実装方法が異なる場合、インタフェース抽象(すなわち、オブジェクト内のマルチステート向けの特性)を用いることができる.だから一般的に実際の開発プロジェクトではインタフェースと抽象クラスは互いに代わるのではなく協力して使用される.
たとえば、すべての受注には単一番号、単価、数量があり、同じであるため、抽象クラスで統一的に記述できます.

public abstract class AbstractOrder{
    private String seriable;//  
    private Double money;//  
    private int number;//  
}

もう1つの商品注文、もう1つの独自の商品名属性があります.新しいProductOrderでAbstractOrderを継承します

public class ProductOrder extends AbstractOrder{
    private String productName;
}

また、すべての注文は支払う必要がありますが、支払い方法は違います.例えば、微信支払い、支付宝支払い、同じ行為ですが、具体的な行為方法は違いますので、1つのインタフェースで抽象化します(行為基準を規定します)

public interface PayWay{
    public boolean pay();
}

public class weixinPayWay implements PayWay{
    @override
    public boolean pay(){
        System.out.println("       ");
        return false;
    }
}

すべての注文は支払う必要があるので、AbstrackOrderクラスを改造して支払い行為を追加するだけです.

Public abstract class AbstractOrder{
    private String serialNo;//  
    private Double money;//  
    private int number;//  
    private PayWay payWay;//    
}

例えば、それぞれの支払い方法は、支払う前に検証する必要があります.支払い金額は本当に不確定で、0以下ではありません.校正方式、校正コードは同じなので、抽象クラスを定義して抽象化することができます.

public abstract class AbstractPayWay implements PayWay{
    private Double money;
    private boolean verify(){
        reurn money !=NULL && money>0;
    }
    /**
         payWay  pay    ，  AbstractPayWay   ，       
    *     doPay（）  ，    doPay（)     f          。
    */
    @override
    public boolean pay(){
        if(!=verify){
            System.out.println("         ");
            return false;
        }
        return this.doPlay();
    }
    
    public abstract boolean doPay();
}

4.個人の心得まとめ
前にも言ったように書きましたが、最後に言っておきます.これらをまとめましょう.
パッケージの利点は、クラスの内部でのみ属性の操作を行うことができることを定義することであり、外部はこれらの属性に手を加えることができず、修正するには、あなたが定義したパッケージ方法しかできません.
継承はコードの冗長性を減らし、多くの重複コードを省略し、開発者は親クラスの下層からすべてのサブクラスに必要な属性と方法を定義し、結合の目的を達成することができる.
多態は方法の個性化を実現し、異なるサブクラスは具体的な状況によって異なる方法を実現することができ、親定義の方法だけでは柔軟ではなく、特殊な状況に遭遇すると窮屈になる.
これらは私の理解であり、皆さんに役に立つことを望んでいます.--要するに、これは本当にとても重要で、java言語のフォローです!皆さんはよく理解して、よく考えて、コードをたくさん書いて、よく考えて、自然に難しくありません.オリジナルのこの文章は本当にとても长い时间を书くことができなくて、みんなが多く支持することができることを望んで、もし分からないことがあるならば私を信じてあるいは地下で评论することができて、见た后に私はできるだけみんなのために解答することができて、みんなはいっしょに学びます.(また、明後日もオリジナルの文章を続々と連載します.私が書いたことがあなたたちに役に立つと思ったら、私に注目して、探しやすいです)
皆さん応援よろしく!!