Java语言基础7

最新推荐文章于 2023-11-25 23:14:16 发布

风暴计划

最新推荐文章于 2023-11-25 23:14:16 发布

阅读量266

点赞数

分类专栏： Java语言基础文章标签：成员变量和局部变量的区别 private关键字 this关键字构造方法匿名对象

本文链接：https://blog.csdn.net/cmm0401/article/details/79866497

版权

Java语言基础专栏收录该内容

68 篇文章 6 订阅

订阅专栏

面向对象思想：成员变量和局部变量的区别、形式参数的两种形式、匿名对象、封装、private关键字、this关键字、内存结构、构造方法、

1、成员变量和局部变量的区别：

（1）在类中的位置不同。

成员变量：在类中方法外。

局部变量：在方法定义中或者方法声明上。

（2）在内存中的位置不同。

成员变量：在堆内存上。

局部变量：在栈内存上。

（3）生命周期不同。

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

局部变量：随着方法的调用而存在，随着方法的调用完毕而消失。

（4）初始化不同。

成员变量：有默认值。byte、short、int、long的默认值是0。float、double的默认值是0.0。boolean的默认值是false。char的默认值是'\u0000'。引用类型的默认值是null。

局部变量：没有默认值，必须定义、赋初值、然后才能使用。

（5）注意事项：局部变量名可以和成员变量名相同，在方法中使用的时候，采用的是就近原则。

2、形式参数的两种形式：Java中只有传值方式

（1）形参是基本类型：形参的改变不影响实参。

（2）形参是引用类型：形参的改变直接影响实参。

/*
	形式参数的问题：
		基本类型：形式参数的改变不影响实际参数
		引用类型：形式参数的改变直接影响实际参数
*/
//形式参数是基本类型
class Demo {
	public int sum(int a,int b) {
		return a + b;
	}
}

//形式参数是引用类型
class Student {
	public void show() {
		System.out.println("我爱学习");
	}
}

class StudentDemo {
	//如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。
	//调用的时候，把main方法中的s的地址传递到了这里 Student s = new Student();
	public void method(Student s) { 
		s.show();
	}
}

class ArgsTest {
	public static void main(String[] args) {
		//形式参数是基本类型的调用
		Demo d = new Demo();
		int result = d.sum(10,20);
		System.out.println("result:"+result);
		System.out.println("--------------");
		
		//形式参数是引用类型的调用
		//需求：我要调用StudentDemo类中的method()方法
		StudentDemo sd = new StudentDemo();
		//创建学生对象
		Student s = new Student();
		sd.method(s); //把s的地址给到了这里
	}
}

3、匿名对象

（1）匿名对象：就是没有名字的对象。
（2）匿名对象的应用场景：
     A: 调用方法，仅仅只调用一次的时候。
        注意：调用多次的时候，不适合。
        那么，这种匿名调用有什么好处吗?
        有，匿名对象调用完毕就是垃圾，可以被垃圾回收器回收。
    B: 匿名对象可以作为实际参数传递。

/*
	匿名对象：就是没有名字的对象。
	
	匿名对象的应用场景：
		A:调用方法，仅仅只调用一次的时候。
			注意：调用多次的时候，不适合。
			那么，这种匿名调用有什么好处吗?
				有，匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
		B:匿名对象可以作为实际参数传递
*/
class Student {
	public void show() {
		System.out.println("我爱学习");
	}
}

class StudentDemo {
	public void method(Student s) {
		s.show();
	}
}

class NoNameDemo {
	public static void main(String[] args) {
		//带名字的调用
		Student s = new Student();
		s.show();
		s.show();
		System.out.println("--------------");
		
		//匿名对象
		//new Student();
		//匿名对象调用方法
		new Student().show();
		new Student().show(); //这里其实是重新创建了一个新的对象
		System.out.println("--------------");
		
		
		//匿名对象作为实际参数传递
		StudentDemo sd = new StudentDemo();
		//Student ss = new Student();
		//sd.method(ss); //这里的ss是一个实际参数
		//匿名对象
		sd.method(new Student());
		
		//在来一个
		new StudentDemo().method(new Student());
 	}
}

4、封装
（1）封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
（2）好处：隐藏实现细节，提供公共的访问方式；提高代码的复用性；提高安全性。
（3）封装原则：将不需要对外提供的内容都隐藏起来。把属性隐藏，提供公共方法对其访问。

（4）private修饰符：

1）private关键字：是一个权限修饰符，可以修饰成员( 成员变量和成员方法 )。被private修饰的成员只能在本类中才能被访问。一般来说，private只修饰成员变量。

2）private最常见的应用：把成员变量用private修饰。提供对应的getXxx()/setXxx()方法。

/*
	定义一个学生类：
		成员变量：name，age
		成员方法：show()方法
		
	我们在使用这个案例的过程中，发现了一个问题：
		通过对象去给成员变量赋值，可以赋值一些非法的数据。
		这是不合理的。
		应该是这个样子的：在赋值之前，先对数据进行判断。
		判断到底在哪里做比较合适呢?
		StudentDemo类是一个测试类，测试类一般只创建对象，调用方法。	
		所以，这个判断应该定义在Student类中。
		而我们在成员变量的位置可不可以进行数据判断呢?
		是不可以的，因为做数据校验，必须要依靠一些逻辑语句。
		逻辑语句是应该定义在方法中的，所以，我们最终决定在Student类中提供一个方法
		来对数据进行校验。
	
	按照我们前面的分析，我们给出了一个方法进行校验。
	但是呢，它偏偏不调用方法来赋值，还是直接赋值了，
	这样我们的方法就没有起到作用。
	我就应该要求你必须使用我的方法，而不能直接调用成员变量赋值。
	怎么去强制要求不能直接使用成员变量呢?
		针对这种情况，Java就提供了一个关键字 private
		
	private:私有的。可以修饰成员变量和成员方法。
		注意：被private修饰的成员只能在本类中访问。
		
	其实，我讲到现在讲解的是一个封装的思想。
	封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
*/
class Student {
	//姓名
	String name;
	//年龄
	private int age;
	
	//写一个方法对数据进行校验
	/*
		返回值类型：void
		参数列表：int a
	*/
	public void setAge(int a) {
		if(a < 0 || age > 120) {
			System.out.println("你给的年龄有问题");
		}else {
			age = a;
		}
	}
	
	
	//show()方法,显示所有成员变量值
	public void show() {
		System.out.println("姓名："+name);
		System.out.println("年龄："+age);
	}
}

class StudentDemo {
	public static void main(String[] args) {
		//创建学生对象
		Student s = new Student();
		s.show();
		System.out.println("--------------");
		
		//给成员变量赋值
		s.name = "林青霞";
		//s.age = 27;
		s.setAge(27);
		s.show();
		System.out.println("--------------");
		
		//给age赋值
		//s.age = -27; //这个数据是不合理的
		//通过方法给值
		s.setAge(-27);
		s.show();
		System.out.println("--------------");
	}
}

一个标准案例的使用：

/*
	封装和private的应用：
		A:把成员变量用private修饰
		B:提高对应的getXxx()和setXxx()方法
*/
//定义学生类
class Student {
	//姓名
	private String name;
	//年龄
	private int age;
	
	//姓名获取值
	public String getName() {
		return name;
	}	
	//姓名设置值
	public void setName(String n) {
		name = n;
	}
	
	//年龄获取值
	public int getAge() {
		return age;
	}	
	//年龄赋值
	public void setAge(int a) {
		age = a;
	}
}

//测试类
class StudentTest {
	public static void main(String[] args) {
		//创建学生对象
		Student s = new Student();
		
		//使用成员变量
		//错误：被私有修饰了，外界不能直接访问了
		//System.out.println(s.name+"---"+s.age);
		System.out.println(s.getName()+"---"+s.getAge());
		
		//给成员变量赋值
		//s.name = "林青霞";
		//s.age = 27;
		//通过方法给赋值
		s.setName("林青霞");
		s.setAge(27);
		System.out.println(s.getName()+"---"+s.getAge());
	}
}

5、this关键字

（1）this：this是当前类的对象引用。也即，this代表当前类的一个对象。

（2）哪个对象调用这个方法，在该方法内部的this就代表就代表该对象。

（3）this的使用场景：解决局部变量隐藏成员变量的问题。

/*
	我们曾经曰：起名字要做到见名知意。	
	this:是当前类的对象引用。简单的记，它就代表当前类的一个对象。	
		注意：谁调用这个方法，在该方法内部的this就代表谁。		
	this的场景：
		解决局部变量隐藏成员变量
*/
//定义学生类
class Student {
	//姓名
	private String name;
	//年龄
	private int age;
	
	//姓名获取值
	public String getName() {
		return name;
	}
	
	//姓名设置值
	public void setName(String name) { //name = "林青霞";
		//name = name; //变量的使用规则：就近原则
		//这里是类名，目前还没有说过类似的用法，所以这个是有问题的
		//这里的调用只能通过对象名
		//这个对象如果存在，它应该代表的是Student的一个对象。
		//那么，谁能够代表当前类的对象呢? java就提供了一个关键字 this
		//Student.name = name;
		this.name = name;
	}
	
	//年龄获取值
	public int getAge() {
		return age;
	}
	
	//年龄赋值
	public void setAge(int age) {
		this.age = age;
	}
}

//测试类
class StudentTest {
	public static void main(String[] args) {
		//创建学生对象
		Student s = new Student();
		
		//给成员变量赋值
		s.setName("林青霞");
		s.setAge(27);
		//获取数据
		System.out.println(s.getName()+"---"+s.getAge());
	}
}

一个标准案例的使用：

/*
	标准的代码改进版	
	this:哪个对象调用那个方法，this就代表那个对象
*/
class Student {
	private String name;
	private int age;
	
	public String getName() {
		return name;     //这里其实是隐含了this
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public int getAge() {
		return age;
	}
	
	public void setAge(int age) {
		this.age = age;
	}
}

class StudentTest2 {
	public static void main(String[] args) {
		//创建一个对象
		Student s1 = new Student();
		s1.setName("林青霞");
		s1.setAge(27);
		System.out.println(s1.getName()+"---"+s1.getAge());
		
		//创建第二个对象
		Student s2 = new Student();
		s2.setName("刘意");
		s2.setAge(30);
		System.out.println(s2.getName()+"---"+s2.getAge());
	}
}

6、构造方法

（1）构造方法的作用：可以给新建对象的数据（成员变量）进行初始化。

（2）构造方法的格式：

A：方法名与类名相同。

B：没有具体的返回值，也即没有返回值类型，连void都没有。

（3）构造方法的注意事项：

A：如果我们没有给出构造方法，则系统会自动提供一个默认的无参构造方法。

B：如果我们给出了构造方法，则系统将不再给出默认的无参构造方法。

（4）构造方法的重载：

A：方法的重载：需要方法的形式参数中的个数不同、或者类型不同、或者顺序不同，但是不能依靠方法的返回值类型的不同来区分。

B：自己设置出无参构造方法和有参构造方法。

C：构造方法的作用：可以给新建对象的数据（成员变量）进行初始化。

（5）建议：永远自己给出类的默认构造方法。

/*
	我们一直在使用构造方法，但是，我们确没有定义构造方法，用的是哪里来的呢?	
	构造方法的注意事项:
		A:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
		B:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
			注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法。		
	给成员变量赋值有两种方式：
		A:setXxx()
		B:构造方法
*/

class Student {
	private String name;
	private int age;

	public Student() {
		//System.out.println("我给了，你还给不");
		System.out.println("这是无参构造方法");
	}
	
	//构造方法的重载格式
	public Student(String name) {
		System.out.println("这是带一个String类型的构造方法");
		this.name = name;
	}
	
	public Student(int age) {
		System.out.println("这是带一个int类型的构造方法");
		this.age = age;
	}
	
	public Student(String name,int age) {
		System.out.println("这是一个带多个参数的构造方法");
		this.name = name;
		this.age = age;
	}
	
	public void show() {
		System.out.println(name+"---"+age);
	}
}

class ConstructDemo2 {
	public static void main(String[] args) {
		//创建对象
		Student s = new Student();
		s.show();
		System.out.println("-------------");
		
		//创建对象2
		Student s2 = new Student("林青霞");
		s2.show();
		System.out.println("-------------");
		
		//创建对象3
		Student s3 = new Student(27);
		s3.show();
		System.out.println("-------------");
		
		//创建对象4
		Student s4 = new Student("林青霞",27);
		s4.show();
	}
}

7、以后提到类成员的话，立即知道一个类的组成：成员变量、成员方法、构造方法。

（1）方法的分类：

根据返回值： void类型非void类型

根据形式参数：空参方法非空参方法

（2）一个标准代码的最终版

/*
	一个标准代码的最终版。	
	学生类：
		成员变量：
			name，age
		构造方法：
			无参，带两个参
		成员方法：
			getXxx()/setXxx()
			show()：输出该类的所有成员变量值			
	给成员变量赋值：
		A:setXxx()方法
		B:构造方法		
	输出成员变量值的方式：
		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 String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public int getAge() {
		return age;
	}
	
	public void setAge(int age) {
		this.age = age;
	}
	
	//输出所有的成员变量值
	public void show() {
		System.out.println(name+"---"+age);
	}
}

//测试类
class StudentTest {
	public static void main(String[] args) {
		//方式1给成员变量赋值
		//无参构造+setXxx()
		Student s1 = new Student();
		s1.setName("林青霞");
		s1.setAge(27);
		//输出值
		System.out.println(s1.getName()+"---"+s1.getAge());
		s1.show();
		System.out.println("----------------------------");
		
		//方式2给成员变量赋值
		Student s2 = new Student("刘意",30);
		System.out.println(s2.getName()+"---"+s2.getAge());
		s2.show();
	}
}

8、Student s=new Student( ); 做了哪些事情？

创建一个类的对象时发生的一系列动作。

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

9、基本的计算器实现

  /*
	定义一个类MyMath,提供基本的加减乘除功能，然后进行测试。
*/
import java.util.Scanner;

class MyMath {
	//加法功能
	public int add(int a,int b) {
		return a + b;
	}
	
	//减法功能
	public int sub(int a,int b) {
		return a - b;
	}
	
	//乘法功能
	public int mul(int a,int b){
		return a * b;
	}
	
	//除法功能
	public int div(int a,int b) {
		return a / b;
	}
}

//测试类
class MyMathTest {
	public static void main(String[] args) {
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入第一个操作数：");
		int firstNumber = sc.nextInt();
		System.out.println("请输入第二个操作数：");
		int secondNumber = sc.nextInt();
		
		//创建MyMath对象，并使用
		MyMath mm = new MyMath();
		
		System.out.println("加法结果："+mm.add(firstNumber,secondNumber));
		System.out.println("减法结果："+mm.sub(firstNumber,secondNumber));
		System.out.println("乘法结果："+mm.mul(firstNumber,secondNumber));
		System.out.println("除法结果："+mm.div(firstNumber,secondNumber));
	}
}