Day07Java基础之构造方法，成员变量，静态变量
- 面向对象（构造方法Constructor概述和格式）
（1） 构造方法概述和作用
给对象的数据（属性）进行初始化
（2） 构造方法的格式特点
a. 方法名与类名相同（大小和类名也一致）
b. 没有返回值类型，连void都没有
c. 没有具体的返回值类型return；
class Demo1_Constructor {
public static void main(String[] args) {
Person p = new Person();//一创建对象的时候，系统就帮我调用了构造方法
//p.Person(); //构造方法不能用对象调用
p.show(); //输出了name=张三 age=23
}
}
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);
}
}
- 面向对象（构造方法的重载及注意事项）
（1） 案例演示：构造方法重载
重载：方法名相同，与返回值类型无关（构造方法没有返回值），只看参数列表
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();
}
}
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);
}
}
（2） 构造方法注意事项
a. 如果我们没有给出构造方法，系统自动提供一个无参构造方法。
b. 如果我们给出了构造方法，系统将不再提供默认的无参构造方法
注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远给出无参构造方法。
3. 面向对象（给成员变量赋值的两种方式的区别）
（1） setXxx()方法
修改属性值
（2） 构造方法
给对象中属性进行初始化
（3） 这两种方式在开发中用setXxx()更多，因为更加灵活
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());
System.out.println(“………………….”);
Person p3= new Person(“李四”,24);
p3.show();
}
}
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 void getName() { //获取姓名
return name;
}
public void setAge(String age) { //设置年龄
this.age = age;
}
public void getAge() { //获取年龄
return age;
}
public void show(){
System.out.println(name + “…” + age);
}
}
- 面向对象（学生类的代码及测试）
（1） 案例演示：一个标准代码的最终版
学生类：
成员变量： name,age
构造方法：无参，带两个参
成员方法：
getXxx()/setXxx()
show():输出该类的所有成员变量值
（2） 给成员变量赋值
a. 通过getXxx()分别获取然后拼接
b. 通过调用show()方法搞定
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(); //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 void getName() { //获取姓名
return name;
}
public void setAge(int age) { //设置年龄
this.age = age;
}
public void getAge() { //获取年龄
return age;
}
public 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();
}
}
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 void getBrand() { //获取品牌
return brand;
}
public void setPrice(int price) { //设置价格
this.price =price;
}
public void getPrice () { //获取价格
return brand;
}
public void show() { //获取价格
System.out.println(brand + “…” + price);
}
}
-
面向对象（创建一个对象的步骤）
1） 画图说明一个对象的创建过程做了哪些事情2） Student s = new Student();
a. Student.class加载进内存
b. 声明一个Student类型的引用s
c. 在堆内存创建对象
d. 给对象中属性默认初始化值
e. 属性进行显示初始化
f. 构造方法进栈，对对象中的属性赋值，构造方法弹栈
g. 将对象的地址值赋值给s -
面向对象（长方形案例练习
需求：
定义一个长方形类，定义 求周长和面积的方法
然后定义一个测试类进行测试
分析：
成员变量：宽width，高high
空参有参构造；
成员方法：setXxx和getXxx;
求周长getLength()；
求面积getArea();
class Test1_Rectangle {
public static void main(String[] args) {
Rectangle r = new Rectangle (10,20); //使用空参构造对象
System.out.println(r.getLength()); //周长
System.out.println(r.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 (String width) { //设置宽
this.width = width;
}
public void getWidth () { //获取宽
return width;
}
public void setHigh (int high) { //设置高
this. high = high;;
}
public void getHigh () { //获取高
return high;
}
public int getLength () { //获取价格
return 2*(width + high);
}
public int getAge() {
return(width * high)；
}
}
- 面向对象（员工类案例练习）
（1）需求：定义一个员工类Employee
（2）自己分析出几个成员，然后给出成员变量
姓名，工号，工资
（3） 构造方法：
空参和有参的
（4） getXxx() setXxx()方法
（5） 以及一个显示所有成员信息的方法并测试
Work
class Test2_Employee {
public static void main(String[] args) {
Employee r = new Employee (“令狐冲” ,”9522”,1000); //使用空参构造对象
r.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 void getName () { //获取姓名
return name;
}
public void setId (String id) { //设置工号
this. id = id;
}
public void getId () { //获取工号
return id;
}
public void setSalary (double salary) { //设置工资
this. salary = salary;
}
public void getSalary () { //获取工资
return salary;
}
public void work () { //获取价格
System.out.println(“我的姓名是：” + name + “，我的工号是：” + id + “我的工资是：” + salary);
}
}
- 面向对象（static关键字及其内存图）
（1） 案例演示,不加静态
人类：Person。每个人都有国籍，日本
（2） 带有static 的内存图
- 面向对象（static关键字的特点）
（1） static关键字的特点
a. 随着类的加载而加载
b. 优先于对象存在
c. 被类的所有对象共享
举例：咱们班级的学生应该共用一个班级编号
什么时候使用静态：
如果某个成员是被所有对象共享的，那么它就应该定义为静态.
举例：饮水机（用静态修饰），水杯（不能用静态修饰）
d. 可以通过类名调用
其实本身也可以通过对象名调用。
推荐使用类名调用。
静态修饰的内容一般称为：与类相关的，类成员。
（2） 案例演示 - 面向对象（static的注意事项）
（1） static的注意事项
a. 在静态方法中是没有this关键字的
静态是随着类的加载而加载，this是随着对象的创建而创建；
静态比对象先存在。
b. 静态方法只能访问静态的成员变量和静态的成员方法
a) 静态方法：
成员变量：只能访问静态变量
成员方法：只能访问静态成员方法。
b) 非静态变量：
成员变量：可以是静态的，也可以是非静态的
成员方法：可以是静态的成员方法，也可以是非静态的成员方法。
c) 静态只能访问静态
（2） 案例演示、
class Demo2_Static {
public static void main(String[] args) {
Demo d = new Demo;
d.print1();
}
}
class Demo {
int num1 = 10; //非静态的成员变量
static int num2 = 20; //静态的成员变量
public void print1 (){ //非静态的成员方法，既可以访问静态的成员变量，也可以访问非静态的成员变量
System.out.println(num1);
System.out.printlc(num2);
}
public static void print2 (){ //静态的成员方法，不能访问非静态的成员变量
System.out.println(num1)；
System.out.printlc(num2);
}
}
- 面向对象（静态变量和成员变量的区别）
静态变量也叫类变量 成员变量也叫对象变量
（1） 所属不同
静态变量是属于类，所以也称为类变量。
成员变量属于对象，所以也成为实例变量（对象变量）。
（2） 内存中的位置不同
静态变量存储于方法去的静态区。
成员变量存储于堆内存。
（3） 内存出现时间不同
静态变量随着类的加载而加载，随着类的消失而消失。
成员变量随着对象的创建而创建，随着对象的消失而消失。
（4） 调用不同
静态成员变量可以通过类名调用，也可以通过对象调用。
成员变量只能通过对象名调用。 - 面向对象（main方法的格式详细讲解）
（1） 格式
public static void main(String[] args) {}
（2） 针对格式的解释
a. public：被jvm调用，访问权限足够大。
b. static：被jvm调用，不用创建对象，直接类名.调用即可。
c. void：被jvm调用，不需要给jvm返回值。
d. main ：一个通用的名称，虽然不是关键字，但是被jvm识别。
e. String[] args 以前用于接收键盘录入的
（3） 案例演示
通过args接收键盘例如数据
class Demo3_Main {
public static void main(String[] args) {
System.out.printlc(args.length);
for(int I = 0;I - 面向对象（工具类使用静态）
（1） 制作一个工具类ArrayTool
a. 获取最大值
b. 数组的遍历
c. 数组的反转
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);
at.print(arr); //打印数组
at.revAray(arr); //反转
at.print(arr); //反转后输出
}
}
/**
这是一个数组工具类里面封装了查找数组最大值，打印数组，数组反转的方法
@author fengjia
@version v1.0
*/
public class ArrayTool {
//如果一个类中的所有的方法都是静态的，需要多做一步，就是私有构造方法,目的是不让其他类创建本类对象。
private ArrayTool() {}
//获取最大值
public static int getMax(int[] arr) {
int max = arr[0]; //记录第一个元素
for (int i = 1;i < arr.length;i++) { //从第二个元素开始遍历
if (max < arr[i]) {
max = arr[i];
}
}
return max;
}
//数组的遍历
public static void print(int[] arr) { //遍历数组
for(int i = 0;i < arr.length;i++) {
System.out.println(arr[i] + “ “);
}
}
//3.数组的反转
public static void revArray(int[] arr) { //遍历数组
for(int i = 0;i < arr.length / 2;i++) { //循环次数为元素个数的一半
int temp = arr[i];
arr[i] = arr[arr.length -1 – i];
arr[arr.length-1-i] = temp;
}
}
}
- 面向对象（说明书的制作过程）
（1） 对工具类加入文档注释，如14例子
（2） 通过javadoc命令生成说明书
@author(提取作者内容)
@version(提取版本内容)
javadoc –d 指定的文件目录 –author –version ArrayTool.java
@param 参数名称//形式参数的变量名称@return 函数运行完返回的数据
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);
at.print(arr); //打印数组
at.revAray(arr); //反转
at.print(arr); //反转后输出
}
}
/**
这是一个数组工具类里面封装了查找数组最大值，打印数组，数组反转的方法
@author fengjia
@version v1.0
*/
class ArrayTool {
//如果一个类中的所有的方法都是静态的，需要多做一步，就是私有构造方法,目的是不让其他类创建本类对象。
/**
私有构造方法
*/
private ArrayTool() {}
//获取最大值
/**
这是获取数组中最大值的方法
@parm 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 = arr[i];
}
}
return max;
}
//数组的遍历
/**
这是遍历数组的方法
@param arr 接收一个int类型的数组
*/
public static void print(int[] arr) { //遍历数组
for(int i = 0;i < arr.length;i++) {
System.out.println(arr[i] + “ “);
}
}
//3.数组的反转
/**
这是一个数组的反转
@param arr 接收一个int类型的数组
*/
public static void revArray(int[] arr) { //遍历数组
for(int i = 0;i < arr.length / 2;i++) { //循环次数为元素个数的一半
int temp = arr[i];
arr[i] = arr[arr.length -1 – i];
arr[arr.length-1-i] = temp;
}
}
}
- 面向对象（使用JDK提供的帮助文档）
（1） 找到文档，打开文档
（2） 点击显示，找到索引，出现输入框
（3） 举例：Scanner
（4） 看这个类的结果（需不需要导包）
成员变量 字段
构造方法 构造方法
成员方法 方法 - 面向对象（学习Math类的随机数功能）
（1） 打开JDK提供的帮助文档学习
（2） Math类概述
类包含用于执行基本数学的算法。
（3） Math类特点
由于Math类在java.lang包下，所以不需要导包。
没有构造方法，因为它的成员全部是静态的。
（4） 获取随机数的方法
public static double random()：返回值带正号的double值，该值大于等于0.0且小于1.0。
（5） 获取一个1-100之间的随机数
int number = (int)(Math.random()*100)+1;
class Demo_Math {
public static void main(String[] args) {
double d = Math.random();
Systemm.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.9999999
// Math.random() * 10 ---- 0.00000 – 99.99999999
//(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));
}
}
}
- 面向对象（猜数字小游戏）
需求：猜数字小游戏（数据在1-100之间）
import java.util.Scanner;
class Teat_GuseeNum {
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 if (result < guessNum) {//如果你们猜的数等于了我心里想的数
System.out.println(“中了”);//中了
break;
}
}
}