javaSE(从0开始)day08

目录

面向对象：

一、构造方法：

                          特点:

               构造方法没有返回值，void也没有，

               如果一个类中没有构造方法，系统会默认赠送一个无参的构造，

               如果手动写了一个构造方法，系统则不赠送 ，

               构造方法调用必须和new关键字配合使用构造方法允许方法的重载

1、定义：

      2、无参构造方法：

      3、有参构造方法：

           （1）参数可以为一个或者多个

           （2）参数类型与属性类型一一对应，参数项里面的变量名可以为属性名，使用成员变量时用 （this.成员变量名） 使用。

   二、成员变量与局部变量：

 （1）成员变量 定义在类内方法外 有默认值，同数组相同 在类内都可以使用

 （2）局部变量 定义在方法内 必须要先声明后赋值再使用 在方法内使用

 （3）成员变量随着对象的创建而产生，随着垃圾回收而消亡，声明周期长

 （4）局部变量随着方法的入线而产生，随着方法的出而消亡，生命周期短 

 （5）当局部变量和成员变量发生重名，优先使用局部。

 三、成员变量私有化（封装）：

  （1）setXX():

  （2） getXX(): 取成员变量的值

  （3）使用private 关键字：

   四、构造代码块：

  （1） 定义

  （2）  静态代码块：

  （3）优先级

  五、构造方法的应用

---

面向对象：

一、构造方法：

        特点:

               构造方法没有返回值，void也没有，

               如果一个类中没有构造方法，系统会默认赠送一个无参的构造，

               如果手动写了一个构造方法，系统则不赠送 ，

               构造方法调用必须和new关键字配合使用构造方法允许方法的重载

      1、定义：

      创建实例的时候，我们经常需要同时初始化这个实例的字段，使用通过构造方法来初始化实例。一个类没有定义构造方法，编译器会自动为我们生成一个默认构造方法，它没有参数，也没有执行语句。

  修饰符  类名（参数项）{

         对成员变量初始化

 }

//方法名与类名同名

      2、无参构造方法：

       类中未定义构造方法的时，系统会默认赠送一个无参构造，当手动添加了构造方法，系统不会赠送无参构造，默认使用手动添加的构造方法。

class Person {
    public Person() {
    }
}

      3、有参构造方法：

           （1）参数可以为一个或者多个

           （2）参数类型与属性类型一一对应，参数项里面的变量名可以为属性名，使用成员变量时用 （this.成员变量名） 使用。

public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

   二、成员变量与局部变量：

 （1）成员变量 定义在类内方法外 有默认值，同数组相同 在类内都可以使用

 （2）局部变量 定义在方法内 必须要先声明后赋值再使用 在方法内使用

 （3）成员变量随着对象的创建而产生，随着垃圾回收而消亡，声明周期长

 （4）局部变量随着方法的入线而产生，随着方法的出而消亡，生命周期短 

 （5）当局部变量和成员变量发生重名，优先使用局部。

 三、成员变量私有化（封装）：

           操作成员变量的时候可能会有非法操作，可以不让外部直接操作成员变量，将成员变私有化，使用private修饰成员变量 ， 提供setXX赋值，有参数无返回值 ，提供getXX取值，有返回值无参数

  （1）setXX():

 主要给成员变量进行赋值，在赋值的过程中会检验参数的合法性

  赋值有参数，无返回值

  此时可以使用this关键字，强制声明使用的变量为成员变量。用法:this.变量名

  （2） getXX(): 取成员变量的值

  （3）使用private 关键字：

可以将成员变量私有化，也可以将方法私有化。（public 公共的 private 私有的）

package com.yuan;

public class Person {
   
    private String name;
  
    private int age;

    //构造方法
    //无参构造： 当未定义构造方法时系统默认赠送一个无参构造
    public  Person(){
        //构造方法中调用其他构造方法，使用this();
        this("张三",20);
        System.out.println("创建一个对象");
    }
    //有参构造：当类中创建了构造方法，默认使用创建的，系统不赠送无参构造
    public  Person(String name,int age){
        System.out.println("创建一个对象");
    }


    public int getAge() {
        return age;
    }
   
    public void setAge(int age) {
        if(age>=0&&age<=120) {
            this.age = age;
        }
    }

    public String getName() {
        return name;
    }

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

    public  void eat(String food){
        System.out.println(name+"喜欢吃"+food);
    }

    public  String showMessage(){
        return "person: {name:"+name+"  age: "+age+"}";
    }

}
class  Test{   //测试类
    public static void main(String[] args) {
        Person p1=new Person();
        p1.setName("张三");
        p1.setAge(20);
        //p1.age=-20
        System.out.println("年龄"+p1.getAge());
        System.out.println(p1.showMessage());
       //使用有参构造
         Person p3=new Person("李四",20);
        System.out.println(p3.showMessage());
        //使用无参构造
        Person p4=new Person();
        String message=p4.showMessage();
        System.out.println(message);

    }

    //
}

   四、构造代码块：

           （1） 定义：

       随着对象的创建被调用，每创建一个对象都会调用一次（创建n个对象，执行n次），优先于构造方法

      { 

            代码

        }

         （2）  静态代码块：

 构造代码块前加static , 随着类的加载而加载(只执行一次)： 优先于构造代码块优先于构造方法

      static { 

            代码

        }

          （3）优先级

      静态代码块 > 构造代码块 > 构造方法

package com.yuan;

public class Payment {

    {
        System.out.println("[预加载]检查支付环境");
        System.out.println("[预加载]生成支付流水号");
        System.out.println("[预加载]启动支付插件");
    }
  
    static{
        System.out.println("这是我的静态代码块");

    }
        public Payment() {
            this(0.01);
        }

        public Payment(double pay) {
             this(pay,"中国银联");
        }

        public Payment(double pay, String way) {
            System.out.println("支付金额￥" + pay);
            System.out.println("默认支付通道" + way);

    }
}
class Test3{
    public static void main(String[] args) {
        Payment p1= new Payment();
        System.out.println("=====================");
        Payment p2 = new Payment();

    }
}

         五、构造方法的应用

1 

public class Vector {
    // 成员变量
    // 容量增长
    private int capacityIncrement;
    // 元素数组
    private Object[] elementData;
    // 构造方法1
    // 定义有参构造方法
    // 传入一个整数类型的参数initialCapacity，作为成员变量elementData的长度完成数组创建
    // 传入一个整型的参数capacityIncrement存入成员变量capacityIncrement中。
 
    // 构造方法2
    // 定义有参构造方法
    // 通过调用“构造方法1”实现
    // 根据传入的参数initialCapacity完成elementData数组的创建
    // 成员变量capacityIncrement的默认值为0
   
    // 构造方法3
    // 定义无参构造方法
    // 通过调用“构造方法2”实现
    // 成员变量elementData数组的长度默认为10

package com.test;

import java.util.Arrays;

public class Vector {
   
    private int capacityIncrement;

   
    private Object[] elementData;

    // 构造方法1
    public Vector(int initialCapacity, int capacityIncrement) {
        this.elementData = new Object[initialCapacity];
        this.capacityIncrement=capacityIncrement;
    }

    // 构造方法2
    public Vector(int initialCapacity) {
        this(initialCapacity, 0);
    }

    // 构造方法3
    public Vector() {
        this(10);
    }

    public int getCapacityIncrement() {
        return capacityIncrement;
    }

    public void setCapacityIncrement(int capacityIncrement) {
        this.capacityIncrement = capacityIncrement;
    }

    public Object[] getElementData() {
        return elementData;
    }

    public void setElementData(Object[] elementData) {
        this.elementData = elementData;
    }

    @Override
    public String toString() {
        return "Vector{" +
                "capacityIncrement=" + capacityIncrement +
                ", elementData=" + Arrays.toString(elementData) +
                '}';
    }
}

class Test {  //测试
    public static void main(String[] args) {
        Vector v1=new Vector();
        System.out.println(v1);
    }

}

 2

public class Order {
    // 成员变量
    // 订单编号
    private String orderId;
    // 订单金额
    private double total;
    // 商品总数
    private int count;

    // 构造方法1
    // 定义无参构造方法
    // 在该构造方法中，将成员变量orderId按照格式初始化：当前日期+8位UUID。例如：20220201-f6a0fecf
    // 其它成员变量忽略
   

    // 构造方法2
    // 定义有参构造方法
    // 在该构造方法中，按照传入参数total、count，分别完成成员变量total、count的初始化，在该构造方法中调用构造方法1，完成orderId的初始化操作

package com.test;

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.UUID;

public class Order {
    
    private String orderId;

    private double total;

    private int count;

    // 构造方法1
    public Order(){
        String str1 = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd"));
        String str= UUID.randomUUID().toString().substring(0,8);
        this.orderId=str1+str;

    }

    // 构造方法2
    public Order(double total,int count){
        this();
        this.total=total;
        this.count=count;

    }

    public String getOrderId() {
        return orderId;
    }

    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }

    public double getTotal() {
        return total;
    }

    public void setTotal(double total) {
        this.total = total;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    @Override
    public String toString() {
        return "Order{" +
                "orderId='" + orderId + '\'' +
                ", total=" + total +
                ", count=" + count +
                '}';
    }
}
class Test2{  //测试
    public static void main(String[] args) {
        Order O1=new Order(2434,5768);
        System.out.println(O1);
    }
}