java面向对象--构造方法/this的使用/方法的重载/static

 一  构造方法

一 什么是构造方法  

      构造方法是一个方法，但它一个特殊的方法，

二 构造方法的特点

      1. 它没有返回值，即使是void型的值也不能够返回。

      2. 构造方法在创建对象时被系统调用(即自动调用，不需要程序员主动调用)。

三构造方法的分类

      无参构造     有参构造

四 构造方法的作用

    可以为属性进行初始化赋值

五 实例说明

   1. 构造方法的编写

//无参构造
 public GouZao() {
    }

//有参构造
 public GouZao(int age, String name) {
        this.age = age;
        this.name = name;
    }

  2. 构造方法的调用

//无参构造方法的调用

public class TestGouZao {
    public static void main(String[] args) {
        GouZao gouZao =new GouZao();   
    }
}

//有参构造方法的调用

public class TestGouZao {
    public static void main(String[] args) {
        GouZao gouZao =new GouZao(15,"zhangsan");
    }
}

六 其他注意事项

     当一个类中没有提供任何构造方法，系统默认提供一个无参数的构造方法。
     如果你写了一个有参的构造函数，那么系统将不提供这个无参数的构造函数，此时我们建议自己手动添加这个无参数的构造函数。
     因为在有些方法调用的过程中，会调用这个无参数的构造函数，这样就会出现错误!
     为了避免这种错误的发生，我们手动添加这个无参数的构造函数！

二this的使用

 一 this是什么意思

   表示当前的

二 this可以修饰哪些内容

 三 实例说明

public class This {

    //创建属性
    private int age;
    private String name;

    //创建构造方法
    public This() {
    }

    public This(int age){
        this();    //调用无参构造，要放在第一行
        this.age=age; 
    }

    public This(int age, String name) {
        this(age);   //调用有参构造，要放在第一行
        this.age = age;
        this.name = name;
    }
    
    //创建普通方法
    public void show(){
        System.out.println(this.name);   //this修饰属性
        this.show2();   //this修饰方法
    }

    public void show2(){
        System.out.println(this.age);
    }
}

四 注意事项

1. 调用构造方法时，要放在第一行

2. 调用父类构造方法或其他构造方法，必须是把 super() 或 this()放在第一行。如果放在其他语句之后，就会导致编译错误。

三 方法的重载

一  什么叫重载   

       在同一个类中，方法名相同，参数列表不同【个数，顺序，类型】， 和返回值类型以及访问修饰符无关。

二 为什么需要重载

      方便根据不同的需求，去调用不同的方法

三 举例说明

1.System.out.println()；就是典型的方法重载

System.out.println()方法就是典型的重载方法，
其内部的声明形式如下 ：
public void println(byte x)
public void println(short x)
public void println(int x)
public void println(long x)
public void println(float x)
public void println(double x)
public void println(char x)
public void println(double x)
public void println()
……

2.  构造方法也可以重载

public class User {
    //属性
    int id; 
    String name; 
    String password;

    //构造方法（构造方法名相同，参数列表不同，是构造方法的重载）
    public User() {
    }

    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public User(int id, String name, String password) {
        this.id = id;
        this.name = name;
        this.password = password;
    }

    //main方法调用
    public static void main(String[ ] args) {
        User u1 = new User();   
        User u2 = new User(01, "张三");
        User u3 = new User(02, "李四", "123456");
    }
}

3.普通方法的重载

    重载方法的编写

public class ChongZai {

    //方法重载必须在同一类中
        public void sum(int a,int b){  // 两个参数 求两个整数的和
            int ans=a + b;
            System.out.println(ans);
        }
        public  void sum(int a,int b,int c){  //三个参数  求三个整数的和
            int ans=a + b + c;
            System.out.println(ans);
        }
        public void sum(int a,int b,int c,int d){  //四个参数  求四个整数的和
            int ans=a + b + c + d;
            System.out.println(ans);
        }  

}

   重载方法的调用

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

        ChongZai t=new ChongZai();  //创建对象

        t.sum(1,2);  //调用两个参数的方法

        t.sum(10,20,30);  //调用三个参数的方法

        t.sum(10,2,3,4);  //调用四个参数的方法

    }
}

四static

一  什么是静态的

    随着类的加载而加载，优先于其他普通属性和方法的存在

二 为什么使用静态

    当在某个特定场合中需要共享某个属性或者方法的时候使用

三 static可以修饰的内容/调用方法

        属性   ：static 属性类型  属性名；      

       方法    ：   static 方法名();    

      代码块 ：static {  代码  }

  调用方法 ：  通过类名点的方式来调用

四 举例说明

public class JingTai {

    //创建静态属性
    static String name;

    //创建静态方法
    public static void show(){
        System.out.println("我是静态方法");
    }

    //创建静态代码块
     static {
         System.out.println("我是静态代码块");
     }

   //main方法执行
    public static void main(String[] args) {
        JingTai.name="zhangsan";   //调用静态属性
        System.out.println(name);    
        JingTai.show();   //调用静态方法
    }
}

五 代码执行的顺序

静态代码块----main方法------静态方法

public class TestAA {
    public static void main(String[] args) {
        System.out.println("main开始了");
        AA.show();
    }
    static {
        System.out.println("我是静态代码块");
    }
    public static void show(){
        System.out.println("我是静态方法");
    }
}

// 执行结果：
// 我是静态代码块   
// main开始了
// 我是静态方法

   六 注意事项

          1. 普通方法可以调用普通方法/静态方法

          2. 静态方法可以调用静态方法，不能调用普通方法

         3. 静态方法中，不可以有this关键字

          4. 静态块优先于main方法执行