封装、继承、单例

封装

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

原文地址：https://www.cnblogs.com/lijun199309/p/9449441.html