Day07Java基础之构造方法，成员变量，静态变量

最新推荐文章于 2022-08-02 18:54:58 发布

小小飞鱼喵

最新推荐文章于 2022-08-02 18:54:58 发布

阅读量204

点赞数

分类专栏：基础知识点

本文链接：https://blog.csdn.net/weixin_44400192/article/details/102917554

版权

基础知识点专栏收录该内容

26 篇文章 0 订阅

订阅专栏

面向对象（构造方法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 <args.length) {
		System.out.println(args[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;
		 }
	 }
}