06 - 构造方法,Static, main, 文档说明书,1-100随机数,猜数字小游戏

1. 构造方法

a. 构造方法概述和作用:
  给对象的数据(属性)进行初始化

b. 构造方法格式特点:
  * 方法名与类名相同(大小也要与类名一致)
  * 没有返回值类型,连void都没有
  * 没有具体的返回值return;

c. 构造方法重载:
  * 案例演示
  * 构造方法的重载
  * 重载:方法名相同,与返回值类型无关(构造方法没有返回值),只看参数列表

d. 构造方法注意事项
  * 如果我们没有给出构造方法,系统将自动提供一个无参构造方法。
  * 如果我们给出了构造方法,系统将不再提供默认的无参构造方法。
  * 注意:这个时候,如果我们还想使用无参构造方法,就必须自己给出。建议永远自己给出无参构造方法

e. 初始化
  构造方法:
    给属性进行初始化
  setXxx方法
    修改属性值

  这两种方式,在开发中用setXxx更多一些,因为比较灵活

f. 学生类:
  * 成员变量:
    * name,age
  * 构造方法:
    * 无参,带两个参
  * 成员方法:
    * getXxx()/setXxx()
    * show():输出该类的所有成员变量值

g. 手机类:
  成员变量:
    品牌brand,价格price
  构造方法
    无参,有参
  成员方法
    setXxx和getXxx
    show

h. 创建一个对象的步骤:
  

 

构造函数的初始化

 

 

    //-------------------------------------------------------------------------------------------
    
    class Demo1_Constructor {                        //Constructor构造
        public static void main(String[] args) {
            Person p = new Person();                //在一创建对象的时候,系统就帮我调用了构造方法
            //p.Person();                            //构造方法不能用对象调用
            p.show();

            Person p2 = new Person();                //再次创建对象
        
            p2.show();
        }
    }

    /*
    * A:构造方法概述和作用
        * 给对象的数据(属性)进行初始化
    * B:构造方法格式特点
        * a:方法名与类名相同(大小也要与类名一致)
        * b:没有返回值类型,连void都没有
        * c:没有具体的返回值return;
    */

    class Person {
        private String name;
        private int age;

        //构造方法
        public Person() {
            //System.out.println("Hello World!");
            //return;                                //构造方法也是有return语句的,格式是return;
            name = "张三";
            age = 23;
        }

        public void show() {
            System.out.println(name + "..." + age);
        }
    }
    
        
    //-------------------------------------------------------------------------------------------
    
    class Demo2_Person {
        public static void main(String[] args) {
            Person p1 = new Person();
            p1.show();

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

            Person p2 = new Person("张三",23);
            p2.show();

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

            Person p3 = new Person("李四",24);
            p3.show();
        }
    }
    /*
    * A:案例演示
        * 构造方法的重载
        * 重载:方法名相同,与返回值类型无关(构造方法没有返回值),只看参数列表
    * B:构造方法注意事项
        * a:如果我们没有给出构造方法,系统将自动提供一个无参构造方法。
        * b:如果我们给出了构造方法,系统将不再提供默认的无参构造方法。
            * 注意:这个时候,如果我们还想使用无参构造方法,就必须自己给出。建议永远自己给出无参构造方法
            
    */
    class Person {
        private String name;            //姓名
        private int age;                //年龄

        public Person() {                //空参构造
            System.out.println("空参的构造");
        }

        public Person(String name,int age) {
            this.name = name;
            this.age = age;
            System.out.println("有参的构造");
        }
        
        public void show() {
            System.out.println(name + "..." + age);
        }
    }
    
            
    //-------------------------------------------------------------------------------------------

    class Demo3_Person {
        public static void main(String[] args) {
            Person p1 = new Person("张三",23);
            //p1 = new Person("张天一",23);    //这种方式看运行结果貌似是改名了,其实是将原对象变成垃圾
            System.out.println(p1.getName() + "..." + p1.getAge());

            System.out.println("--------------------");
            Person p2 = new Person();        //空参构造创建对象
            p2.setName("李四");
            p2.setAge(24);

            p2.setName("李鬼");
            System.out.println(p2.getName() + "..." + p2.getAge());
        }
    }
    /*
    构造方法
        给属性进行初始化
    setXxx方法
        修改属性值
        这两种方式,在开发中用setXxx更多一些,因为比较灵活
    */
    class Person {
        private String name;                //姓名
        private int age;                    //年龄

        public Person() {                    //空参构造
        }

        public Person(String name,int age) {//有参构造
            this.name = name;
            this.age = age;
        }
        
        public void setName(String name) {    //设置姓名
            this.name = name;
        }

        public String getName() {            //获取姓名
            return name;
        }

        public void setAge(int age) {        //设置年龄
            this.age = age;
        }

        public int getAge() {                //获取年龄
            return age;
        }
    }
    
    //-------------------------------------------------------------------------------------------------
    
    class Demo4_Student {
        public static void main(String[] args) {
            Student s1 = new Student();                    //使用空参构造
            s1.setName("张三");                            //设置姓名
            s1.setAge(23);                                //设置年龄

            System.out.println("我的姓名是:" + s1.getName() + ",我的年龄是:" + s1.getAge());
            //getXxx()获取属性值,可以打印,也可以赋值给其他的变量,做其他的操作
            Student s2 = new Student("李四",24);
            s2.show();                                    //只是为了显示属性值
        }
    }
    /*
    * A:案例演示
        * 学生类:
            * 成员变量:
                * name,age
            * 构造方法:
                * 无参,带两个参
            * 成员方法:
                * getXxx()/setXxx()
                * show():输出该类的所有成员变量值
    * B:给成员变量赋值:
        * a:setXxx()方法
        * b:构造方法
        
    * C:输出成员变量值的方式:
        * a:通过getXxx()分别获取然后拼接
        * b:通过调用show()方法搞定
    */

    class Student {
        private String name;                            //姓名
        private int age;                                //年龄

        public Student(){}                                //空参构造

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

        public void setName(String name) {                //设置姓名
            this.name = name;
        }

        public String getName() {                        //获取姓名
            return name;
        }

        public void setAge(int age) {                    //设置年龄
            this.age = age;
        }

        public int getAge() {                            //获取年龄
            return age;
        }

        public void show() {
            System.out.println("我的姓名是:" + name +  ",我的年龄是:" +  age);
        }
    }
    
    //-----------------------------------------------------------------------------------------------
    
    class Demo5_Phone {
        public static void main(String[] args) {
            Phone p1 = new Phone();
            p1.setBrand("苹果");
            p1.setPrice(1500);
            System.out.println(p1.getBrand() + "..." + p1.getPrice());

            Phone p2 = new Phone("小米",98);
            p2.show();
        }
    }
    /*
    手机类:
        成员变量:
            品牌brand,价格price
        构造方法
            无参,有参
        成员方法
            setXxx和getXxx
            show
    */
    class Phone {
        private String brand;                        //品牌
        private int price;                            //价格

        public Phone(){}                            //空参构造

        public Phone(String brand,int price) {        //有参构造
            this.brand = brand;
            this.price = price;
        }

        public void setBrand(String brand) {        //设置品牌
            this.brand = brand;
        }

        public String getBrand() {                    //获取品牌
            return brand;
        }

        public void setPrice(int price) {            //设置价格
            this.price = price;
        }

        public int getPrice() {                        //获取价格
            return price;
        }

        public void show() {
            System.out.println(brand + "..." + price);
        }
    }
    
    //------------------------------------------------------------------------------------------------
    class Demo1_Student {
        public static void main(String[] args) {
            Student s = new Student();
            s.show();
        }
    }

    class Student {
        private String name = "张三";
        private int age = 23;

        public Student() {
            name = "李四";
            age = 24;
        }

        public void show() {
            System.out.println(name + "..." + age);
        }
    }

 

2. 构造方法 - 练习

 2.1 求长方形的周长和面积

        class Test1_Rectangle {                            //Rectangle矩形
            public static void main(String[] args) {
                Rectangle r = new Rectangle(10,20);
                System.out.println(r.getLength());        //周长
                System.out.println(r.getArea());        //面积
            }
        }
        /*
        * A:案例演示
            * 需求:
                * 定义一个长方形类,定义 求周长和面积的方法,
                * 然后定义一个测试类进行测试。
            分析:
                成员变量:
                    宽width,高high
                空参有参构造
                成员方法:
                    setXxx和getXxx
                    求周长:getLength()
                    求面积:getArea()
        */
        class Rectangle {
        private int width;                //
        private int high;                //

        public Rectangle(){}            //空参构造

        public Rectangle(int width,int high) {
            this.width = width;            //有参构造
            this.high = high;
        }

        public void setWidth(int width) {//设置宽
            this.width = width;
        }

        public int getWidth() {            //获取宽
            return width;
        }

        public void setHigh(int high) {    //设置高
            this.high = high;
        }

        public int getHigh() {            //获取高
            return high;
        }

        public int getLength() {        //获取周长
            return 2 * (width + high);
        }

        public int getArea() {            //获取面积
            return width * high;
        }
    }

 

 2.2. 员工的姓名,工号,工资

    class Test2_Employee {                        //employee员工
            public static void main(String[] args) {
                Employee e = new Employee("令狐冲","9527",20000);
                e.work();
            }
        }
        /*
        * A:案例演示
            * 需求:定义一个员工类Employee
            * 自己分析出几个成员,然后给出成员变量
                * 姓名name,工号id,工资salary 
            * 构造方法,
                * 空参和有参的
            * getXxx()setXxx()方法,
            * 以及一个显示所有成员信息的方法。并测试。
                * work 
        */
        class Employee {
            private String name;                    //姓名
            private String id;                        //工号
            private double salary;                    //工资

            public Employee() {}                    //空参构造

            public Employee(String name, String id, double salary) {//有参构造
                this.name = name;
                this.id = id;
                this.salary = salary;
            }

            public void setName(String name) {        //设置姓名
                this.name = name;
            }

            public String getName() {                //获取姓名
                return name;
            }

            public void setId(String id) {            //设置id
                this.id = id;
            }

            public String getId() {                    //获取id
                return id;
            }

            public void setSalary(double salary) {    //设置工资
                this.salary = salary;
            }
            
            public double getSalary() {                //获取工资
                return salary;
            }

            public void work() {
                System.out.println("我的姓名是:" + name + ",我的工号是:" + id + ",我的工资是:" + salary 
                    + ",我的工作内容是敲代码");
            }
        }
            

3. Static

 没有static之前:

 

有static之后:

 

  a. 总结:
        共性:用静态;
        特性:用非静态;
        可以通过类名来调用;
    
    b. 注意:
        * a:在静态方法中是没有this关键字的
            * 如何理解呢?
                * 静态是随着类的加载而加载,this是随着对象的创建而存在。
                * 静态比对象先存在。
        * b:静态方法只能访问静态的成员变量和静态的成员方法
            * 静态方法:
                * 成员变量:只能访问静态变量
                * 成员方法:只能访问静态成员方法
            * 非静态方法:
                * 成员变量:可以是静态的,也可以是非静态的
                * 成员方法:可是是静态的成员方法,也可以是非静态的成员方法。
            * 简单记:
                * 静态只能访问静态。    

 

class Demo1_Static {
    public static void main(String[] args) {
        /*Person p1 = new Person();    //创建对象
        p1.name = "苍老师";            //调用姓名属性并赋值
        p1.country = "日本";        //调用国籍属性并赋值
        

        Person p2 = new Person();
        p2.name = "小泽老师";        //调用姓名属性并赋值
        //p2.country = "日本";        //调用国籍属性并赋值

        p1.speak();
        p2.speak();*/

        Person.country = "日本";    //静态多了一种调用方式,可以通过类名.
        System.out.println(Person.country);
    }
}

class Person {
    String name;                    //姓名
    static String country;                    //国籍

    public void speak() {            //说话的方法
        System.out.println(name + "..." + country);
    }
}

//----------------------------------------------------------------------------------

class Demo2_Static {
    public static void main(String[] args) {
        //Demo d = new Demo();
        //d.print1();

        Demo.print2();
    }
}

/*
* A:static的注意事项
    * a:在静态方法中是没有this关键字的
        * 如何理解呢?
            * 静态是随着类的加载而加载,this是随着对象的创建而存在。
            * 静态比对象先存在。
    * b:静态方法只能访问静态的成员变量和静态的成员方法
        * 静态方法:
            * 成员变量:只能访问静态变量
            * 成员方法:只能访问静态成员方法
        * 非静态方法:
            * 成员变量:可以是静态的,也可以是非静态的
            * 成员方法:可是是静态的成员方法,也可以是非静态的成员方法。
        * 简单记:
            * 静态只能访问静态。
*/

class Demo {
    int num1 = 10;                        //非静态的成员变量
    static int num2 = 20;                //静态的成员变量

    /*public void print1() {                //非静态的成员方法,既可以访问静态的成员也可以访问非静态的
        System.out.println(num1);
        System.out.println(num2);
    }*/

    public static void print2() {        //静态的成员方法
        //System.out.println(this.num1);//静态的成员方法不能访问非静态的,错误: 无法从静态上下文中引用非静态 变量 num1
        System.out.println(num2);
    }
}    
    

 

4. main

public : 被jvm调用,所以权限要足够大
static : 被jvm调用,不需要创建对象,直接类名.调用即可
void   : 被jvm调用,不需要有任何的返回值
main   : 只有这样写才能被jvm识别,main不是关键字
String[] args : 以前是用来接收键盘录入的

class Demo3_Main {
    public static void main(String[] args) {            
        /*
        public : 被jvm调用,所以权限要足够大
        static : 被jvm调用,不需要创建对象,直接类名.调用即可
        void   : 被jvm调用,不需要有任何的返回值
        main   : 只有这样写才能被jvm识别,main不是关键字
        String[] args : 以前是用来接收键盘录入的
        */

        System.out.println(args.length);
        for (int i = 0;i < args.length ;i++ ) {
            System.out.println(args[i]);
        }
    }
}

5. 私有构造方法,文档说明书

如果一个类中所有的方法都是静态的,需要再多做一步,私有构造方法,目的是不让其他类创建本类对象。
直接用类名.调用即可

文档说明书:
  javadoc -d api -version -author ArrayTest.java
  就会生成文档说明书

    /**
    这是一个数组工具类,里面封装了查找数组最大值,打印数组,数组反转的方法
    @author fengjia
    @version v1.0
    */
    public class ArrayTool {
        //如果一个类中所有的方法都是静态的,需要再多做一步,私有构造方法,目的是不让其他类创建本类对象
        //直接用类名.调用即可
        /**
        私有构造方法
        */
        private ArrayTool(){}

        //1,获取最大值

        /**
        这是获取数组中最大值的方法
        @param arr 接收一个int类型数组
        @return 返回数组中最大值
        */
        public static int getMax(int[] arr) {
            int max = arr[0];                        //记录第一个元素
            for (int i = 1;i < arr.length ;i++ ) {    //从第二个元素开始遍历
                if (max < arr[i]) {                    //max与数组中其他的元素比较
                    max = arr[i];                    //记录住较大的
                }
            }

            return max;                                //将最大值返回
        }
        //2,数组的遍历
        /**
        这是遍历数组的方法
        @param arr 接收一个int类型数组
        */
        public static void print(int[] arr) {
            for (int i = 0;i < arr.length ;i++ ) {    //遍历数组
                System.out.print(arr[i] + " ");
            }
        }
        //3,数组的反转
        /**
        这是数组反转的方法
        @param arr 接收一个int类型数组
        */
        public static void revArray(int[] arr) {
            for (int i = 0;i < arr.length / 2 ;i++ ) {    //循环次数是元素个数的一半
                /*
                arr[0]与arr[arr.length-1-0]    交换
                arr[1]与arr[arr.length-1-1]    交换
                arr[2]与arr[arr.length-1-2] 交换
                */
                int temp = arr[i];
                arr[i] = arr[arr.length-1-i];
                arr[arr.length-1-i] = temp;
            }
        }
    }
    
    ----------------------------------------------------
    class Demo1_ArrayTool {
        public static void main(String[] args) {
            int[] arr = {33,11,22,66,55,44};
            /*ArrayTool at = new ArrayTool();
            int max = at.getMax(arr);                //获取最值
            System.out.println(max);
            
            System.out.println("---------------");
            at.print(arr);                            //打印
            System.out.println();
            System.out.println("---------------");
            System.out.println("反转后:");
            at.revArray(arr);                        //反转
            at.print(arr);    */

            ArrayTool.print(arr);
        }
    }
    

 

6. 1-100的随机数,猜数字小游戏

class Demo2_Math {
        public static void main(String[] args) {
            //double d = Math.random();
            //System.out.println(d);
            
            //Math.random()会生成大于等于0.0并且小于1.0的伪随机数
            for (int i = 0;i < 10 ;i++ ) {
                System.out.println(Math.random());
            }

            //生成1-100的随机数
            //Math.random()0.0000000 - 0.999999999
            //Math.random() * 100 ====> 0.00000 - 99.999999999
            //(int)(Math.random() * 100) ====> 0 - 99
            //(int)(Math.random() * 100) + 1

            for (int i = 0;i < 10 ;i++ ) {
                System.out.println((int)(Math.random() * 100) + 1);
            }
        }
    }
    
    ========================================================
    /*
    * A:案例演示
        * 需求:猜数字小游戏(数据在1-100之间)
    */
    import java.util.Scanner;
    class Test1_GuessNum {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);                //创建键盘录入对象
            System.out.println("请输入一个整数,范围在1-100之间");
            int guessNum = (int)(Math.random() * 100) + 1;        //心里想的随机数
            while (true) {                                        //因为需要猜很多次,所以用无限循环
                int result = sc.nextInt();                        //大家猜的数
                if (result > guessNum) {                        //如果你们猜的数大于了我心里想的数
                    System.out.println("大了");                    //提示大了
                } else if (result < guessNum) {                    //如果你们猜的数小于了我心里想的数
                    System.out.println("小了");                    //提示小了
                } else {                                        //如果既不大也不小
                    System.out.println("中了");                    //中了
                    break;
                }
            }
        }
    }
posted @ 2019-06-18 21:09  Alice的小屋  阅读(178)  评论(0编辑  收藏  举报