【Java构造方法 06】

一、方法重载的条件

1、方法名是相同的

2、方法的参数类型，个数，顺序至少有一个不同

3、方法的返回值类型可以不同，因为方法的重载与返回值类型没有任何关系

4、方法重载只能出现在同一个类里面

5、方法的修饰符可以不同，因为方法的重载与修饰符没有关系

二、构造方法，构造器，构造函数

1、构造方法也是方法

2、构造方法语法：

　　[修饰符] 构造方法名（参数列表）{

　　构造方法体　　

}

3、构造方法名必须和类型相同

4、构造方法的作用：

　　A、调用构造方法可以创建Java对象，怎么调用呢？使用new关键字调用（注：其他地方的调用，采用“别名.xxx”）

　　B、构造方法的执行除了创建Java对象之外，还可以初始化成员变量

5、如果一个类不手动提供任何构造方法，系统会默认提供一个没有参数的构造方法，如果手动提供了，系统则不会再默认创建了

6、构造方法是可以重载的

7、成员变量在构造方法执行的时候才会被初始化

注意：构造方法没有返回值类型，并且不能写void

package com.company.Course6Exercises;

/**
人类：
属性：私有的  年龄int  性别char

构造方法：
无参，给年龄赋值12 性别赋值为男
有两个参数，初始化年龄和性別

成员方法：
修改年龄
得到年龄
修改性別
得到性别
打印方法，方法名字print，实现打印:年龄是xxx,性别是xxx
*/

class People {
    private int age;
    private char sex;

    //上下两个构造方法的重载
    People(){
        age = 18;
        sex = '男';
    }

    People(int _Age, char _Sex){
        age = _Age;
        sex = _Sex;
    }


    void setAge(int _age){
        age = _age;
    }
    int getAge(){
        return age;
    }

    void setSex(char _sex){
        sex = _sex;
    }
    char getSex(){
        return sex;
    }

    public static void print(){

        //调用无参的构造方法
//        People p = new People();
        //调用有参的构造方法
        People p = new People(20,'男');
        System.out.println("年龄："+p.getAge()+" 性别："+p.getSex());
    }
}

package com.company.Course6Exercises;

/**
 * @Created by IntelliJ IDEA.
 * @Author tk
 * @Date 2019/10/9
 * @Time 15:11
 */
public class Person {
    public static void main(String[] args){
        People.print();
    }

}

温习构造方法，成员方法，方法重载，对象的引用

package com.JavaStudy.study0421;

/**  创建动物类
 *   定义一个动物类：
 *   属性：名字，腿
 *
 *   构造方法：
 *   1、无参：给名字赋值xxx，给腿赋值4
 *   2、两个参数，分别给名字和腿赋值
 *
 *   两个成员方法（负载）move方法：
 *   1、无参，打印"xxx在移动"
 *   2、一个参数int n: 打印"n次xxx在移动"
 *
 */
public class Animal {
    String name;
    int leg;

    //方法内的变量是局部变量，局部变量对成员变量进行修改，则必须两者进行关联
    Animal(){
        name="猫";
        leg =4;
    }
    Animal(String _name,int _leg){
        name =_name;
        leg=_leg;
    }

    public void move(){

        System.out.println(name+"在移动");
    }

    public void move(int n){
        System.out.println(n+"次"+name+"在移动");
    }

    public static void main(String[] args){
        Animal a1 = new Animal();
        Animal a2 = new Animal("哈士奇",4);
        a1.move();
        a1.move(4);

        a2.move();
        a2.move(4);
    }
}

封装，属性私有化的例子

package com.JavaStudy.study0421;

/**
 设计一个圆类：要求：
 1、有一个私有的成员变量半径
 2、有一个缺省构造器
 3、有三个成员方法如下：
 第一个方法，能改变圆的半径
 第二个方法，能得到圆的半径
 第三个方法，能计算圆的面积
 */
public class Round {
    private float r;

    Round(){}

    public void setR(float r){
        this.r = r;
    }

    public float getR() {
        return r;
    }

    public float area(float r){
         return (float) (3.14 * r * r);
    }

    public static void main(String[] args){
        Round round = new Round();
        round.setR(2.5f);
        float result = round.area(round.getR());
        System.out.println("圆的面积："+result);
    }

}

三、static的用法（静态代码块）

1、static修饰的数据被称作“静态的”

2、使用static关键字可以定义静态代码块

3、静态代码块在类加载阶段执行，并且只执行一次，是自上而下的顺序依次执行

package com.company.StaticMothod;

/**
 * @Created by IntelliJ IDEA.
 * @Author tk
 * @Date 2019/10/11
 * @Time 10:55
 */
public class StaticMothod {  
    //static静态代码块，在类加载的时候从上而下执行

    static {
        System.out.println("m1");
    }
    static {
        System.out.println("m2");
    }
    static {
        System.out.println("m3");
    }
    public static void main(String[] args){
        System.out.println("验证静态代码块是不是自上而下执行！");
    }
}
====执行结果======
m1
m2
m3
验证静态代码块是不是自上而下执行！

四、实例代码块

1、每调用一次构造方法，则实例代码块就会执行一次

2、实例代码块在构造方法调用之前执行

3、实例代码块也是自上而下的顺序执行

package com.company.StaticMothod;

/**
 * @Created by IntelliJ IDEA.
 * @Author tk
 * @Date 2019/10/11
 * @Time 14:14
 */
public class Instance {

    //实例代码块是在构造方法调用之前执行
    {
        System.out.println("M1");
    }

    Instance(){
        System.out.println("构造方法调用！！！");
    }

    {
        System.out.println("M2");
    }

    {
        System.out.println("M3");
    }



    public static void main(String[] args){
        System.out.println("main begin");

        new Instance();

        new Instance();
    }
}

=======执行结果========
main begin
M1
M2
M3
构造方法调用！！！
M1
M2
M3
构造方法调用！！！

说明：从执行结果看，首先运行主函数的，然后运行实例代码，最后才运行构造方法
由此可以看出实例代码也是从上而下运行的并且在构造方法之前

五、所有的static修饰的数据，正规的访问方式是：类名.

static修饰的变量叫做静态变量

static修饰的方法叫做静态方法

什么情况下声明成静态变量？

  所有的对象都有这个特征，并且这个特征所对应的值都是相同的。

  没必要声明成员变量，因为浪费内存

  应该声明成静态变量，在方法去只存储一份没让所有的对象共享这一份数据。

  参数的工具类中的方法都是静态的，目的是方便调用。

package com.company.StaticMothod;

/**
 * @Created by IntelliJ IDEA.
 * @Author tk
 * @Date 2019/10/11
 * @Time 16:28
 */
public class StaticTest {

    //需求：请抽象一个类描述现实世界中的"陆生生物"
    public static void main(String[] args){

        Anamal a1 = new Anamal("熊猫",3);
        Anamal a2 = new Anamal("孔雀",5);

        System.out.println(Anamal.type);
    }
}

class Anamal{
    String name;
    int age;

    static String type="陆生";

    Anamal(String _name,int _age){
        name = _name;
        age = _age;
    }
}

//主要知识点：静态数据，调动通过"类名."

======先声明变量，后面才能调用======

 private static String name = "SUN";
    
    static {
        System.out.println(name);
    }

5.1、所有对象可以共享一个静态数据

package com.JavaStudy.study0421;

/**
 * @Created by IntelliJ IDEA.
 * @Author wufq
 * @Date 2020/4/23 17:10
 * static关键字实现计数器
 */
public class StaticLiZi {

    public static void main(String[] args){

        /*
        为什么会实现static计数：
        1、每调用一次构造方法，就会创建一个对象并且会初始化i=0
        2、d1调用时，构造方法Dog和成员方法print会发生压栈和弹栈动作，弹栈后分配的内存是仍然存在的并且被保存到main方法中，此时i=1
        3、d2调用时，同样会进行压栈和弹栈，静态变量i值在1的基础上被修改为2，依次到d5调用i值就会被叠加被修改。
        4、所以就实现了计数
         */
        Dog d1 = new Dog();
        d1.print();

        Dog d2 = new Dog();
        d2.print();

        Dog d3 = new Dog();
        d3.print();

        Dog d4 = new Dog();
        d4.print();

        Dog d5 = new Dog();
        d5.print();

    }
}

class Dog{
    static int i;

    Dog(){
        i++;
    }

    public void print(){
        System.out.println("一共有"+i+"条狗");
    }
}

六、类内能出现的元素

类{

　　成员变量；

　　成员方法；

　　静态变量；

　　静态方法；

　　构造方法

　　静态代码块；

　　实例代码块；

}

 七、static对应的模式：单例模式（堆里面只有一个对象，只有一个堆内存地址）(如果有不同的对内存地址就不是单例模式)，不能被继承

1、不是单例模式的例子

package com.JavaStudy.study0421;

/**
 * @Created by IntelliJ IDEA.
 * @Author wufq
 * @Date 2020/4/23 17:54
 * 非单例模式
 */
public class StaticFdiLi {
    public static void main(String[] args){
        User u1 = new User();
        User u2 = new User();

        /*
        分别创建了u1,u2两个对象，两个对象就会对应两个不同的内存地址
         */

        //判断两个对象是不是一个内存地址，执行后发现打印的是false说明就不是一个内存地址，所以不是单例模式
        if(u1 == u2){
            System.out.println("true");
        }else{
            System.out.println("false");
        }
    }
}

class User{
    //缺省构造器
    public User(){}
}


=====执行结果=====
false

两种单例模式：饿汉单例模式，懒汉单例模式

1、懒汉式单例模式

package com.company.StaticMothod;

/**
测试User类是否符合单例模式
 单例模式主要解决的问题：保证JVM中该类型Java对象只有一个

 优点：节省内存的开始

 缺点：单例模式中因为构造方法私有化，所以单例模式无法被继承
 因为在子类构造方法中必须使用父类中的构造方法
 */

//懒汉式单例模式
public class DanLi {
    //静态变量
    private static DanLi d;

    /*
    第一步：将所有的构造方法私有化
    目的是：让外部程序不能直接用构造方法创建对象
    因为只要构造方法执行，就会有一个对象诞生
     */

    private DanLi(){}

    //对外提供一个公开获取DanLi类型对象的方法
    public static DanLi getInstance(){
        if(d == null){
            d = new DanLi();
        }
        return d;
    }

}

class T{
    public static void main(String[] args){

        DanLi d1 = DanLi.getInstance();
        DanLi d2 = DanLi.getInstance();

        System.out.println(d1 == d2);
    }
}

=====执行结果=====
true

分析：
1、先声明一个私有变量d，说明堆内会生成一个对象d，值为null
2、DanLi.getInstance()：调用getInstance方法时，由于d的初始值已经为nulll，则继续走if判断，创建对象，所以可以继续调动getInstance（）对象。

 this和static的例子

静态方法和成员方法有一个区别：

1、如果有成员变量，静态方法想使用成员变量，必须有形式参数，然后把形式参数（局部变量）赋值给成员方法，这样在方法体内才能用的上成员变量

比如：

//成员方法
class Trigon{
    static double bottom; 
    double high;

    Trigon(double high){
        this.high = high;
    }

    //area方法是一个私有的方法，不能被其他类调用，所以需要在本类内用print方法进行调用
    private double area(){ 

        return high*bottom/2;  //成员方法内使用成员变量
    }

    public  void print(){

        System.out.println(this.area());

    }