面向对象第二天（Java）

面向对象第二天（Java）

构造方法的概述和使用

重载（overload）的定义及特点

成员变量显示初始化的两种方式

static关键字的使用

main方法的格式详细解释

Math类的随机数功能及Random类的使用

1、构造方法的作用：给对象的数据（属性）进行初始化。
   构造方法我们观察得到的特点： 
     (1)构造方法没有返回值，连个void都没有.
     (2) 构造方法的方法名非常特殊，它和类名完全一样.
     (3) 假如想创建一个对象，必然要通过它的构造方法才能进行创建.
     (4) 默认情况下，我们可以忽略最原始最简单的这个构造方法.
     (5) 构造方法可以有多个，建议大家手写这个默认的构造方法因为一旦有了自己写的构造方法（函数），会覆盖原有的默认的构造方法.
 2、static关键字的特点：
     (1)随着类的加载而加载。
     (2)优先于对象而存在。
     (3)被类的所有对象所共享。
     (4)可以直接被类名调用，也可以通过对象的方式去调用，但一般推荐使用类名调用。
     (5)存储位置：方法区中的静态区。
   静态方法只能访问静态的成员变量和静态的成员方法;主方法(main)是静态的。
 3、静态变量也叫类变量，成员变量(存储于堆内存;随着对象的创建而存在，随着对象的消失而消失;只能通过对象名调用)也叫对象变量。

    package com.hwadee;

public class TestPerson {

    public static void main(String[] args) {
        Persons prs=new Persons();
        prs.setAge(19);
        prs.setName("码小生");

        int age = prs.getAge();
        String name = prs.getName();
        System.out.println("年龄="+age+"，姓名="+name);

        System.out.println("\n"+"----------------"+"\n");

        Staticcountry sc=new Staticcountry();
        sc.print1();
        //访问被static修饰的方法：通过类名.方法名的方式
        Staticcountry.print2();

        System.out.println("\n"+"-----------------"+"\n");
        //访问被static修饰的变量：通过类名.变量名的方式
        System.out.println(Staticcountry.country1);     
    }
}
class Staticcountry{
    static String country1="中国,这个变量是被static修饰的";//静态成员变量
    String country2="China";//非静态成员变量

    public Staticcountry() {

    }
    //非静态的成员方法，既可以访问静态的成员，也可以访问非静态的
    public void print1() {
        System.out.println(country1);
        System.out.println(country2);
    }
    /*
     * 静态的成员方法
     * 静态的成员方法不能访问非静态的，错误：无法从静态上下文中引用非静态变量country2
     */
    public static void print2() {
        System.out.println("这个方法是被static修饰的");
        System.out.println(country1);
        //System.out.println(country2);
    }   
}
class Persons{
    private String name;
    private int age;
    //构造方法
    public Persons() {
        System.out.println("这是一个Persons类的对象");
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }   
}

4、 重载(overload)：同一个类中 方法名必须相同 参数列表不同 
   混淆了构造方法和方法的重载:
     (1)构造方法是可以重载的，只不过构造方法很特殊，它没有返回值，连个void都没有
     (2)构造方法的目的是：创建一个对象
     (3)overload它的特点：两同一不同---->同一个类中，方法名相同，但输入参数列表不同

package com.hwadee;

public class TestFigure {

    public static void main(String[] args) {

        //构造方法的重载
        Add a=new Add(5,6);

        System.out.println("-----------------------------");
        //方法的重载
        Add ad=new Add();

        int printAdd1 = ad.printAdd(8, 7, 2);
        System.out.println(printAdd1);

        int printAdd2 = ad.printAdd(1,5,3,6);
        System.out.println(printAdd2);
    }
}
class Add{

    public Add() {      
    }
    public Add(int a,int b) {
        int c;
        c=a+b;
        System.out.println("两个数相加="+c);
    }

    public int printAdd(int a,int b,int c) {
        int d=a+b+c;
        return d;
    }

    public int printAdd(int a,int b,int c,int d) {
        int e=a+b+c+d;
        return e;
    }   
}

5、单例模式：常用的设计模式有大概23种。设计模式之单例模式：
      单--->单就是1，就是单独，仅仅只有一个的意思
      例--->单个对象
      实例<--->对象    单例也就是单个对象
      单例模式指的是只有一个实例（对象）
      例如：打印机对外暴露只有一个打印实例
      单例模式的目的：保证该类只有一个对象。
      怎么办？
      第一步：把构造方法私有；
      第二步：在成员位置自己创建一个对象；
      第三步：通过一个公共的方法访问。

package com.hwadee;

public class Best {

    public static void main(String[] args) {
        Teacher t1 = Teacher.getTeacher();
        Teacher t2 = Teacher.getTeacher();
        System.out.println(t1==t2);

        System.out.println("--------------------------");

        Students s1 = Students.getStudents();
        Students s2 = Students.getStudents();
        System.out.println(s1==s2);     
    }
}

//懒汉式
class Teacher{
    private static Teacher t;
    private Teacher() {

    }
    public static Teacher getTeacher(){
        if(t==null) {
            t=new Teacher();
        }
        return t;
    }
}
//饿汉式
class Students{
    private static Students ss=new Students();
    private Students() {

    }
    public static Students getStudents() {
        return ss;
    }
}

6、main方法的格式详细解释:
    (1)public被jvm调用，访问权限足够大。
    (2)static被jvm调用，不用创建对象，直接类名访问。
    (3)void被jvm调用，不需要给jvm返回值。
    (4)main 一个通用的名称，不是关键字，只有这样写才能被jvm识别。
    (5)String[] args以前用于接收键盘录入的。

package com.hwadee;

public class Main1 {

    public static void main(String[] args) {//String数组定义为args
        System.out.println(args.length);
        //当注释掉上面的直接输出语句时，没有运行结果，这是因为args的长度本身就是0
        for(int i=0;i<args.length;i++) {
            System.out.println(args[i]);
        }
    }
}

7、Math类的随机数功能及Random类的使用
   学会使用JDK提供的帮助文档学习

package com.hwadee;

import java.util.Random;

public class Math1 {

    public static void main(String[] args) {
        //Math.random()会生成大于等于0.0并且小于1.0的伪随机数
        double r1=Math.random();
        System.out.println(r1);

        System.out.println("------------------------");

        //生成0.0到10.0的伪随机数
        double r2=Math.random()*10;
        System.out.println(r2);

        System.out.println("------------------------");

        //使用Random类生成伪随机数
        Random r=new Random();
        int a=r.nextInt();
        System.out.println(a);      
    }
}