封裝

package com.qianfeng.test;
//封裝性:(根據對屬性的封裝來說明):把對成員變量的訪問進行私有化,通過一個公共的方法間接的實現訪問.
//好處:提高了代碼的安全性,增加了代碼的可讀性和復用性.
public class Demo2 {
    public static void main(String[] args) {
        /*
         * 開槍射擊
         */
        Gun gun = new Gun();
        //我們把程序中出現的不符合邏輯的數據稱為臟數據
        /*
         * 原因:直接將臟數據賦值給了成員變量
         * 解決:1.不要將數據直接賦值給成員變量--將成員變量私有化
         * 2.通過方法間接的訪問他,在方法內先過濾,再賦值
         
 
*/
        //gun.bulletNumber = -5;
        gun.addBullet(-5);
        gun.shoot();
        /*
         * 因為對所有的屬性都要進行賦值取值,所以系統指定了一整套的規範--get,set
         * set:--賦值的過程
         * 構成: 修飾詞  返回值  方法名(參數列表){方法體
         *         return 返回值
         * }
         * 修飾詞:一定是public
         * 返回值:是void
         * 方法名:set+成員變量的名字,但是需要首字母大寫.
         * 參數列表:只有一個參數,並且參數的類型和名字與成員變量一致
         * 方法體:不需要return    要寫的代碼是:this.成員變量=參數的名字
         * get:--取值的過程
         * 構成: 修飾詞  返回值  方法名(參數列表){方法體
         *         return 返回值
         * }
         * 修飾詞:一定是public
         * 返回值:類型與成員變量一致
         * 方法名:get+成員變量的名字,但是需要首字母大寫.
         * 參數列表:不需要參數
         * 方法體的代碼:return  成員變量
         * 
         * 快捷方式:shift+alt+s
         
 
*/
    }
}

class Gun{
    //被private修飾的只能在當前類內可見
    private int bulletNumber;
    private int age;
    private String name;
    private double weight;
    private double height;
    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 double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    //子彈的添加
    public void addBullet(int bulletNumber){
        //過濾的過程
        if (bulletNumber >=0) {
            this.bulletNumber = bulletNumber;
        }else {
            this.bulletNumber = 0;
        }
    }
    
    public void setBulletNumber(int bulletNumber){
        this.bulletNumber = bulletNumber;
    }
    public int getBulletNumber() {
        return bulletNumber;
    }
    
    //射擊方法
    public void shoot(){
        if (bulletNumber > 0) {
            --bulletNumber;
        }
        System.out.println("剩下的子彈數量:"+ bulletNumber);
    }
}
繼承
package com.qianfeng.test;
/*
 * 繼承:有兩個類A類與B類,當讓他們之間產生父子的關系,就叫繼承
 * 
 * B繼承自A     B extends A
 * 
 * 重寫:當子類有與父類同名(方法名,參數,返回值等都要相同)的方法.
 * 註意點:相當於子類的同名方法將父類的覆蓋了,不會再去調用父類方法.
 * 
 * 作用:在不改變父類名字的前提下,在父類原有功能的基礎之上,實現一些屬於自己的功能.實現對原有功能的擴充.
 * 
 * this:是一種引用數據類型,保存的是當前對象的地址,代表當前的對象
 * super:是一個關鍵字,但是不是引用數據類型.可以通過super調用父類的成員
 * 
 * 註意事項:
 * 1.私有方法不能被重寫
 * 2.子類的同名方法的權限要大於等於父類的同名方法
 * 3.靜態的方法只能覆蓋靜態的方法
 */
public class Demo3 {
    public static void main(String[] args) {
        Iphone iphone = new Iphone();
        iphone.color = "綠色";//調用父類的屬性
        iphone.fangShui();//調用自己的方法
        //子類調用父類的方法原理:首先由引用找到當前的子類對象,在當前的對象裏面找這個方法,找到了,直接調用.找不到,再去父類中找
        //依次執行,直到找到Object,如果還是沒有,說明確定沒有這個方法,報錯.
        iphone.callPhone();//調用父類的方法
    }
}
//註意:如果什麽都不寫,默認父類是Object
class Phone{
    String color;
    int model;
    
    public void callPhone(){
        System.out.println("打電話");
    }
    
    public static void play(){
        
    }
}

//描述的是 Iphone 繼承自 Phone
class Iphone extends Phone{
//    String color;
//    int model;
    String gui;
    
    public void callPhone(){
        //this.callPhone();//調用的本對象的callPhone方法--死循環
        super.callPhone();//直接調用的父類的方法
        
        System.out.println("執行自己的功能");
    }
    
    public void fangShui(){
        
        System.out.println("防水");
    }
    
    //靜態的方法只能覆蓋靜態的
    public static void play() {

    }
}

class HuaWei extends Phone{
//    String color;
//    int model;
    
//    public void callPhone(){
//        System.out.println("打電話");
//    }
//    
    public void Niu(){
        System.out.println("牛");
    }
}
繼承的構造方法
package com.qianfeng.test;
/*
 * 繼承中構造方法的使用
 * 
 * 1.當一個子類中只有一個帶參數的構造方法,只能使用帶參數的,不能使用無參的.如果想使用,必須手動建立無參的構造方法
 * 2.當父類中只有帶參數的構造方法,子類的構造方法中就必須在第一行手動調用父類帶參數的構造方法(super(參數))
 * 3.當我們創建構造方法的時候,如果自己不寫super(),系統會自動調用
 * 原因:父類中也有屬性要進行初始化,而對象的屬性必須由自己的構造方法進行初始化,所以必須調用super(),
 * 所以每個構造方法中都默認有一個super()
 * 
 * 為什麽要將super放在方法的第一行?
 * 答:在子類的構造方法中有可能用到父類的屬性,而屬性在使用之前必須先進行初始化,否則無法使用.
 * 
 * 總之:在繼承體系中,作為父類最好的辦法就是將無參構造方法和有參構造方法都寫了.
 */
public class Demo4 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.getName();
    }
}

class Animal{
    private String name;

    public String getName() {
        return name;
    }

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

    public Animal() {

    }

    public Animal(String name) {
        this.name = name;
    }
    
}

class Dog extends Animal{
    //無參構造方法
    public Dog() {
        //super();//默認調用父類的無參構造方法
        //註意:這行代碼必須放在第一行
        super("拉布拉多");//手動調用父類有參構造方法
        
        
    }
    //有參構造方法
    public Dog(String name) {
        super("拉布拉多");
        this.setName(name);
    }
}
單例
package com.qianfeng.test;
/*
 * 設計模式:前人總結出來的經驗後人直接拿來使用.
 * 設計模式種類:23種       常用的:單例,模板,工廠,裝飾,適配器,代理
 * 單例設計模式:一個類只允許有一個對象,建立一個全局的訪問點,提供出去供大家使用
 * 分析:
 * 要設計單例類:
 * 1.用戶只能有一個對象
 * 2.建立全局的訪問點?  得到的對象就是全局的訪問點.    怎麽做到全局? static
 * 3.提供出去?
 * 4.供大家使用?--單例的功能.
 * 
* 單例類的作用:1.可以實現兩個對象之間的傳值
  * 2.可以在全局範圍內調用很多的功能.
 * 好處:可以讓兩個對象在完全沒有關系的前提下,實現值的傳遞,降低了耦合性,提高了內聚性
 * 
 * 耦合性,內聚性在微觀上說:描述的是類與類之間的關系
 * 好處:我們應該盡量提高內聚性,減少耦合性,可以提高程序的健壯性,增加代碼的可移植性,方便實現模塊兒化編程
 * 
 * 如何做到低耦合高內聚?
 * 在處理類與類關系的時候,讓類之間的關系越緊密耦合性越高,內聚性越低.反之,關系越松散耦合性越低,內聚性越高.
 */

//創建單例類
//餓漢式:在定義變量的同時完成初始化
class SingleInstance{
    //2.在類的內部創建一個私有的對象
    //將singleInstance變成靜態的--相當於提供全局的訪問點
    private static SingleInstance singleInstance = new SingleInstance();
    //1.將構造方法私有化
    private SingleInstance() {
    }
    
    //3.通過一個公共的方法將變量提供出去,供大家訪問
    //將公共方法變成靜態的
    public static SingleInstance getInstance(){
        return singleInstance;
    }
    
    //功能區--非靜態的成員
    int num;
}

//懶漢式:什麽時候使用什麽時候賦值
class SingleInstance1{
    //在類的內部創建一個私有的對象
    //將singleInstance變成靜態的--相當於提供全局的訪問點
    private static SingleInstance1 singleInstance = null;
    //將構造方法私有化
    private SingleInstance1() {
    }
    
    //通過一個公共的方法將變量提供出去,供大家訪問
    //將公共方法變成靜態的
    public static SingleInstance1 getInstance(){
        if (singleInstance == null) {
            singleInstance = new SingleInstance1();
        }
        return singleInstance;
    }
    
    //功能區--非靜態的成員
}


public class Demo5 {
    public static void main(String[] args) {
        //SingleInstance已經被私有化,不能再直接調用
//        SingleInstance singleInstance1 = new SingleInstance();
//        SingleInstance singleInstance2 = new SingleInstance();
//        System.out.println(singleInstance1 == singleInstance2);//false
        
        //讓用戶獲取單例對象
//        SingleInstance singleInstance1 = SingleInstance.getInstance();
//        SingleInstance singleInstance2 = SingleInstance.getInstance();
//        System.out.println(singleInstance1 == singleInstance2);//true
        
        //實現功能:將A類的對象中的num1的值傳給B類的對象的屬性num2
        
        //第一種方式:直接賦值,但是一般類的成員變量都是私有的,所以不推薦
        A a = new A();
        a.num1 = 4;
        
        B b = new B();
        b.num2 = a.num1;
        
        //第二種:通過傳參
        b.test(a);
        
        //第三種方式:通過單例
        a.ceshiDanli1();
        b.ceshiDanli2();
    }
}
class A{
    int num1;
    
    //通過單例傳值
    public void ceshiDanli1(){
        SingleInstance singleInstance = SingleInstance.getInstance();
        singleInstance.num = num1;
    }
}

class B{
    int num2;
    
    //通過傳參
    public void test(A a){
        num2 = a.num1;
    }
    
    //通過單例傳值
    public void ceshiDanli2(){
        SingleInstance singleInstance = SingleInstance.getInstance();
        num2 = singleInstance.num;
    }
}

求兩點距離代碼

package day08ketang;
import java.util.Scanner;
public class demo05 {
        public static void main(String[] args) {
                Scanner scanner = new Scanner(System.in);
            System.out.print("請輸入點1的橫坐標:");
                double x1 = scanner.nextDouble();
            System.out.print("請輸入點1的縱坐標:");
                double y1 = scanner.nextDouble();
                Point2 p1=new Point2(x1, y1);
                System.out.print("點1的坐標為：");
                /*
                 * 考慮人性化 按坐標形式打印
                 */
                p1.show();
            System.out.print("請輸入點2的橫坐標:");
                double x2 = scanner.nextDouble();
            System.out.print("請輸入點2的縱坐標:");
                double y2 = scanner.nextDouble();
                Point2 p2=new Point2(x2, y2);
                System.out.print("點2的坐標為：");
                /*
                 * 考慮人性化 按坐標形式打印
                 */
                p2.show();
                 /*
                   * 方法一  靜態調用
                   */
//                double distance = Point2.distance(p1, p2);
                /*
                 *  方法二 非靜態調用
                 */
            double distance = p1.distance(p2);
            System.out.println("兩點之間的距離為: " + distance);
        }
}

class Point2 {
    public  double x;
    public  double y;
    /*
     * 有參構造函數
     */
        public Point2(double x, double y){
            this.x = x;
            this.y = y;
        }
        /*
         * 考慮人性化 按坐標形式打印
         */
          public void show(){
                System.out.println("("+x+","+y+")");
            }
          /*
           * 方法一  靜態方法
           */
        public static double distance(Point2 p1, Point2 p2){
//            return Math.sqrt(Math.pow(p1.getX() - p2.getX(), 2) + Math.pow(p1.getY()-p2.getY(), 2));
            return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y-p2.y, 2));
        }
        /*
         *  方法二 非靜態方法
         */
        public  double distance(Point2 p){
            return Math.sqrt((p.x-x)*(p.x-x)+(p.y-y)*(p.y-y));
        }
        
        
        public  double getX() {
            return x;
        }
        public  double getY() {
            return y;
        }
}

封裝、繼承、單例