java面向对象---new对象

1.创建一个对象的步骤

一个对象的创建过程做了哪些事情?
Student s = new Student();
步骤:

• (1):加载Student.class文件进内存
• (2):在栈内存为s开辟空间
• (3):在堆内存为学生对象开辟空间
• (4):对学生对象的成员变量进行默认初始化
• (5):对学生对象的成员变量进行显示初始化
• (6):通过构造方法对学生对象的成员变量赋值
• (7):学生对象初始化完毕，把对象地址赋值给s变量

一个小案例：创建对象时的内存分析；
栈中存放main和一些引用，堆中存放new出来的；

2.长方形案例练习

需求：
	定义一个长方形(Rectangle)类,定义求周长(length)和面积(area)的方法,
	然后定义一个测试类Test，进行测试。

public class test {
    public static void main(String[] args) {
        Rectangle c = new Rectangle(4,6);
        System.out.println(c.周长());
        System.out.println(c.面积());
    }
}
/**
 * 定义一个长方形类，求周长和面积的方法
 * 然后定义一个测试类进行测试
 *
 */

class Rectangle{
    private int a;
    private int b;

    public Rectangle() {  //无参构造


    }


    public Rectangle(int a, int b) {   //有参构造
        super();
        this.a = a;
        this.b = b;
    }

    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }

    public int getB() {
        return b;
    }

    public void setB(int b) {
        this.b = b;
    }

    public int 周长(){
        return (a+b)*2;
    }

    public int 面积(){
        return a*b;
    }
}

3.static关键字

3.1static关键字的特点

• a:随着类的加载而加载
• b:优先于对象存在
• c:被类的所有对象共享
  举例：咱们班级的学生应该共用同一个班级编号。
  其实这个特点也是在告诉我们什么时候使用静态?
  如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
  举例：
  饮水机(用静态修饰)
  水杯(不能用静态修饰)
• d:可以通过类名调用
  其实它本身也可以通过对象名调用。
  推荐使用类名调用。
  静态修饰的内容一般我们称其为：与类相关的，类成员

public class Person {
    public String name;
    //static 静态的：可以修饰成员变量，成员方法，修饰成员变量，此变量就变成了共享变量
    public static  String guoji="中国";
}
public class MyTest {
    public static void main(String[] args) {
        //我想并把中国这个 数据，设置成共享数据，让多个对象，去共享这个数据
        Person.guoji="英国";
        //被静态所修饰的成员，属于类的 推荐使用类名直接调用
        //被static所修饰的成员变量，我们称之为类变量

        Person p1 = new Person();

        p1.name = "张三";
       // p1.guoji = "美国";


        Person p2 = new Person();
        p2.name = "李四";
        //p2.guoji = "中国";


        Person p3 = new Person();
        p3.name = "王五";
        // p3.guoji = "中国";


        System.out.println(p1.name);
        System.out.println(p1.guoji);


        System.out.println(p2.name);
        System.out.println(p2.guoji);


        System.out.println(p3.name);
        System.out.println(p3.guoji);
    }
}

3.2static的注意事项

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

public class Cat {
    public String name; //实例变量
    public static int num = 20;  //方法区的静态区 被类的所有对象所共享 类变量

    //实例方法：
    public void test() {
        System.out.println("这是一个非静态的test方法");
        //非静态的方法，既能访问静态的，也能访问非静态的
        System.out.println(name);
        System.out.println(num);
    }

    //静态方法：静态只能访问静态的，不能非静态的
    public static void show() {
        System.out.println("这是一个静态的show方法");
        //加载时机的问题 被静态所修饰的成员，随着类的加载而加载加载时机早，实例变量创建对象的时候才存在，是后来才有的
        // 先来的肯定找不到后来的
        // System.out.println(name);
        System.out.println(num);
    }

    public void test2() {
        //方法中有一个隐藏的对象this
        this.test();
    }

    //在静态方法里面，不能出现this this也是代表一个对象，对象是后来才有的
    public static void test3() {
        //方法中有一个隐藏的对象this
        // this.test(); //报错
        Cat.show();
    }
}

4.静态变量和成员变量的区别

• A:所属不同
  静态变量属于类，所以也称为类变量
  成员变量属于对象，所以也称为实例变量(对象变量)
• B:内存中位置不同
  静态变量存储于方法区的静态区
  成员变量存储于堆内存
• C:内存出现时间不同
  静态变量随着类的加载而加载，随着类的消失而消失
  成员变量随着对象的创建而存在，随着对象的消失而消失
• D:调用不同
  静态变量可以通过类名调用，也可以通过对象调用,推荐使用类名调用
  成员变量只能通过对象名调用

5.如何使用JDK提供的帮助文档

• A:找到文档，打开文档
• B:点击显示，找到索引，出现输入框
• C:你应该知道你找谁?举例：Scanner
• D:看这个类的结构(需不需要导包)
  java.lang包下的内容不需要我们手动导入
  其它包下的内容需要我们手动导入
  类 API文档
  成员变量 字段摘要
  构造方法 构造方法摘要
  成员方法 方法摘要
• E:看这个类的说明(简单的了解一下)
• F:看开始版本
• G:看构造方法
• H:看成员方法
  • 看左边:
    是否是static的,如果是我们就不需要创建对象,直接可以使用类名调用该方法;看返回值,返回值是什么我就使用什么接收
  • 看右边:
    看参数列表: 参数的个数 , 参数的类型 ; 要什么参数我是用的时候,就传递什么参数
• I:然后使用

6.学习Math类的随机数功能

打开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 static void main(String[] args) {
        double d = Math.random();  //生成一个随机小数
        System.out.println(d);
        
        //生成1-100的随机数
        int a = (int)(Math.random()*100+1);
        System.out.println(a);
    }

}  

案例演示: 需求：猜数字小游戏(数据在1-100之间)

public class GuessNumber {
    public static void main(String[] args) {
      /*  A:
        案例演示:
        需求：猜数字小游戏(数据在1 - 100之间)*/
        int num = (int) ((Math.random() * 100) + 1);

        while (true) {
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入一个整数 1---100");
            int userNum = scanner.nextInt();
            //比对
            if (userNum > num) {
                System.out.println("你猜大了");
            } else if (userNum < num) {
                System.out.println("你猜小了");
            } else {
                System.out.println("恭喜你！猜对了");
                break;
            }
        }
    }
}