Java编程基础08——面向对象_构造方法&静态static

摘要：如果我们给出了构造方法，系统将不再提供默认的无参构造方法。概念方便在没有创建对象的情况下来进行调用方法变量。因为它的成员全部是静态的所以私有了构造方法获取随机数的方法返回带正号的值，该值大于等于

A:构造方法概述和作用

给对象的数据(属性)进行初始化

B:构造方法格式特点

a:方法名与类名相同(大小写也要与类名一致)

b:没有返回值类型，连void都没有

c:没有具体的返回值return;

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

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

class Person {
    private String name; //成员变量都私有
    private int age;

    //构造方法
    public Person() {
        //System.out.println("hello");
        //return;                    //构造方法也是有return语句的；
        name = "张三";
        age = 23;
    }
    public void show() {
        System.out.println(name + "..." + age);
    }
}

A:案例演示

构造方法的重载

重载:在同一类中,方法名相同,与返回值类型无关(构造方法没有返回值),只看参数列表

有参构造的好处:可以动态的给属性赋值

B:构造方法注意事项

a:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。

b:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。

注意：这个时候，如果我们还想使用无参构造方法，就必须自己手动给出，应自己给出无参构造方法。

public class JavaObject {    //创建对象
    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();
    }
}
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);
    }

}

A：setXxx()方法—— 修改属性值(开发中用的多一些,因为灵活)

B：构造方法—— 给对象中属性进行初始化。

public class JavaObject {    //创建对象phone  
    public static void main(String [] args) {
        Person p1 = new Person("张三",23);
        p1 = new Person("李天一",25);    //将元对象变成了垃圾
        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());
    }
}
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;
    }
}

A:案例演示 学生类：

成员变量：name，age

构造方法：无参，带两个参

成员方法： getXxx()/setXxx() java bean类(实体类) show()：输出该类的所有成员变量值

B:给成员变量赋值：

a:setXxx()方法

b:构造方法

C:输出成员变量值的方式：

a:通过getXxx()分别获取然后拼接

b:通过调用show()方法搞定

c:两者区别:
getXxx()获取属性值,可以打印,也可以赋值给其他的变量,做其他的操作
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);
    }
}
public class JavaObject {    
    public static void main(String [] args) {
        Student s1 = new Student();  //空参构造创建对象
        s1.setName("李四");   //设置姓名
        s1.setAge(24);        //设置年龄
        System.out.println("我的姓名是" + s1.getName() + "..." + "我的年龄是" + s1.getAge());
        System.out.println("-------------------");
        //getXxx()获取属性值，可以打印，也可以赋值给其他的变量，做其他的操作
        Student s2 = new Student("张三",23); //使用有参构造
        s2.show();   //只是为了显示属性值
    }
}

成员变量：品牌brand，价格price

构造方法：无参有参

成员发法：setXxxh和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);
    }
}
public class JavaObject {    
    public static void main(String [] args) {
        Phone s1 = new Phone();  //空参构造创建对象
        s1.setBrand("小米");   //设置品牌
        s1.setPrice(2400);        //设置价格
        System.out.println("品牌名称是" + s1.getBrand() + "..." + "价格是" + s1.getPrice());
        System.out.println("-------------------");
        //getXxx()获取属性值，可以打印，也可以赋值给其他的变量，做其他的操作
        Phone s2 = new Phone("张三",23); //使用有参构造
        s2.show();   //只是为了显示属性值
    }
}

画图说明一个对象的创建过程(如何加载到内存)做了哪些事情?

Student s = new Student();

1,Student.class加载进内存

2,声明一个Student类型引用s

3,在堆内存创建对象,

4,给对象中属性默认初始化值

5,属性进行显示初始化

6,构造方法进栈,对对象中的属性赋值,构造方法弹栈

7,将对象的地址值赋值给s

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

    public Student() {        
        name = "李四";
        age = 24;
    }
    public void show() {
        System.out.println(name + "..." + age);
    }
}
class JavaObject {    
    public static void main(String [] args) {
        Student s = new Student();  //空参构造创建对象
        s.show();   //只是为了显示属性值
    }
} 

A:案例演示

需求：

定义一个长方形类,定义 求周长和面积的方法，

然后定义一个测试类进行测试。

分析

成员变量：宽width，高height，空参有参构造setXxxx和getXxx;

求周长getLength()，求面积getArea()

class Rectangle {
    private int width;
    private int height;


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

    public void setWidth(int width) { //设置宽
        this.width = width;
    }
    public int setWidth() {   //获取宽
        return width;
    }
    public void setheight(int height) { //设置高
        this.height = height;
    }
    public int setheight() {   //获取高
        return height;
    }



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

    public int getArea() {  //获取面积
        return width * height;
    }
}
class JavaObject {    
    public static void main(String [] args) {
        Rectangle s = new Rectangle(10,20);  //空参构造创建对象
        System.out.println(s.getLenght());    //周长
        System.out.println(s.getArea());    //面积
    }
}

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 setName() {   //获取姓名
        return name;
    }
    public void setId(String id) { //设置工号
        this.id = id;
    }
    public String setId() {   //获取工号
        return id;
    }
    public void setSalary(double salary) { //设置工资
        this.salary= salary;
    }
    public double setSalary() {   //获取工资
        return salary;
    }

    public void work() {  //获取信息
        System.out.println("我的姓名是" + name + "，工号是" + id + "，工资是" + salary);
    }

}

class JavaObject {    
    public static void main(String [] args) {
        Employee e = new Employee("令狐冲","20000",40000);  //空参构造创建对象
            e.work();
    }
}

A:案例演示

通过一个案例引入static关键字。

人类：Person。每个人都有国籍，中国。

B:概念

方便在没有创建对象的情况下来进行调用（方法/变量）。

static可以用来修饰类的成员方法、类的成员变量，另外可以编写static代码块来优化程序性能。

class Person {
    String name;
    static String country;
    public void speak() {  //说话的方法
        System.out.println(name + "..." + country);
    }
}
class JavaObject {    
    public static void main(String [] args) {
        Person e = new Person();  //创建对象
            e.name = "张老师";    //调用姓名属性并赋值
            e.country = "中国"; //调用国籍属性并赋值
            e.speak();
        Person f = new Person();  //创建对象
            f.name = "李老师";    //调用姓名属性并赋值
            //f.country = "中国"; //调用国籍属性并赋值
            f.speak();
    }
} 

A:static关键字的特点

a:随着类的加载而加载

b:优先于对象存在

c:被类的所有对象共享

举例：咱们班级的学生应该共用同一个班级编号。

其实这个特点也是在告诉我们什么时候使用静态?

如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。

举例：

饮水机(用静态修饰)

水杯(不能用静态修饰)

共性用静态,特性用非静态

d:可以通过类名调用

其实它本身也可以通过对象名调用。

推荐使用类名调用。

静态修饰的内容一般我们称其为：与类相关的，类成员

B:案例演示

static关键字的特点

class Person {
    String name;
    static String country;
    public void speak() {  //说话的方法
        System.out.println(name + "..." + country);
    }
}
class JavaObject {    
    public static void main(String [] args) {
        Person.country = "日本";  //静态多了一种调用方式，可以通过类名。
            System.out.println(Person.country);
    }
}

A:static的注意事项

a:在静态方法中是没有this关键字的

如何理解呢?

静态是随着类的加载而加载，this是随着对象的创建而存在。

静态比对象先存在。

b:静态方法只能访问静态的成员变量和静态的成员方法

静态方法：

成员变量：只能访问静态变量

成员方法：只能访问静态成员方法

非静态方法：

成员变量：可以是静态的，也可以是非静态的

成员方法：可是是静态的成员方法，也可以是非静态的成员方法。

简单记：

静态只能访问静态。

B:案例演示

static的注意事项

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(num1);  //静态的成员方法不能访问费静态的 变量 num1
        System.out.println(num2);
    }
}
class JavaObject {    
    public static void main(String [] args) {
       // Demo d = new Demo();  //静态多了一种调用方式，可以通过类名。
      //    d.print1();

        Demo.print2();
    }
}

静态变量也叫类变量 成员变量也叫对象变量

A:所属不同

静态变量属于类，所以也称为为类变量

成员变量属于对象，所以也称为实例变量(对象变量)

B:内存中位置不同

静态变量存储于方法区的静态区

成员变量存储于堆内存

C:内存出现时间不同

静态变量随着类的加载而加载，随着类的消失而消失

成员变量随着对象的创建而存在，随着对象的消失而消失

D:调用不同

静态变量可以通过类名调用，也可以通过对象调用

成员变量只能通过对 象名调用

A:格式

public static void main(String[] args) {}

B:针对格式的解释

public 被jvm调用，访问权限足够大。

static 被jvm调用，不用创建对象，直接类名访问

void被jvm调用，不需要给jvm返回值

main 一个通用的名称，虽然不是关键字，但是被jvm识别

String[] args 以前用于接收键盘录入的

C:演示案例

通过args接收键盘例如数据

class JavaObject {    
    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])
       }
    }
}  

A:制作一个工具类

ArrayTool

1,获取最大值

2,数组的遍历

3,数组的反转

加static静态化
如果一个类中所有的方法都是静态的，需要多做一步，私有构造方法，
private ArrayTool(){}
目的是不让其他类创建本类对象,直接用类名调用即可.

//文件ArrayTool.java

    class ArrayTool {
        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;//将最大值返回
        }
        public static void print(int[] arr) {
            for (int i = 0;i < arr.length ; i++ ) { // 遍历数组
                System.out.print(arr[i] + " ");
            }
        }
        public static void revArray(int[] arr) {
            for (int i = 0; i < arr.length / 2; i++) { //循环次数是元素个数的一半
                //arr[0]与arr[arr.length-1-0]交换
                int temp = arr[i];
                arr[i] = arr[arr.length-1-i];
                arr[arr.length-1-i] = temp;
            }
        }
    }

//文件Demo_ArrayTool.java

class Demo_ArrayTool {
    public static void main(String[] args) {
        int[] arr = {11,66,22,33,44,55,};
        /*
        非静态的调用方法
        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);
    }
}

A:对工具类加入文档注释

B:通过javadoc命令生成说明书

@author(提取作者内容)

@version(提取版本内容)

javadoc -d 指定的文件目录 -author -version ArrayTool.java

@param 参数名称//形式参数的变量名称@return 函数运行完返回的数据

/**
这是一个数组工具类，里面封装了查找数组最大值，打印数组，数组反转方法。
@author  zhengaidong
@version v1.0
*/

public class JavaObject {
    /**
    私有构造方法
    */
    private JavaObject(){
    }
    /**
    这是获取数组中最大值得方法
    @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;//将最大值返回
    }

    /**
    这是遍历数组的方法
    @param arr 接收一个int类型的数组
    */
    public static void print(int[] arr) {
        for (int i = 0;i < arr.length ; i++ ) { // 遍历数组
            System.out.print(arr[i] + " ");
        }
    }
    /**
    这是数组反转的方法
    @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]交换
            int temp = arr[i];
            arr[i] = arr[arr.length-1-i];
            arr[arr.length-1-i] = temp;
        }
    }
}

A:找到文档，打开文档

B:点击显示，找到索引，出现输入框

C:你应该知道你找谁?举例：Scanner

D:看这个类的结构(需不需要导包)

成员变量 字段

构造方法 构造方法

成员方法 方法

打开JDK提供的帮助文档学习

A:Math类概述

类包含用于执行基本数学运算的方法

B:Math类特点

由于Math类在java.lang包下，所以不需要导包。

因为它的成员全部是静态的,所以私有了构造方法

C:获取随机数的方法

public static double random():返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。

D:我要获取一个1-100之间的随机数，肿么办?

int number = (int)(Math.random()*100)+1;

public class JavaObject {
    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的随机数0.00000000000000-0.999999999999999
        //Math.random() * 100 ==>0.000000 - 99.9999999999
        //(int)(Math.random() * 32) ====> 0 - 99
        //(int)(Math.random() * 100) + 1

        for (int i = 0;i < 7 ;i++ ) {
            System.out.println((int)(Math.random() * 32) + 1);
        }
    }
}

A:案例演示

需求：猜数字小游戏(数据在1-100之间)

import java.util.Scanner;
public class JavaObject {
    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 x = sc.nextInt();
            if (x > guessNum) {
                System.out.println("大了");
            } else if (x < guessNum) {
                System.out.println("小了");
            } else {
                System.out.println("中了");
                break;
            }
        } 
    }
}