java基础七（成员变量局部变量匿名对象封装设计原则 private this 构造方法 static）

最新推荐文章于 2022-11-29 17:53:54 发布

陌上离离

最新推荐文章于 2022-11-29 17:53:54 发布

阅读量826

点赞数

分类专栏： java 自学java入门文章标签：局部变量对象设计

本文链接：https://blog.csdn.net/qq_35155205/article/details/64439086

版权

java 同时被 2 个专栏收录

42 篇文章 0 订阅

订阅专栏

自学java入门

8 篇文章 0 订阅

订阅专栏

1:成员变量和局部变量的区别（变量：variable）
(1)在类中的位置不同
成员变量：类中方法外
局部变量：方法定义中或者方法声明上
(2)在内存中的位置不同
成员变量：在堆内存
局部变量：在栈内存
(3)生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
(4)初始化值不同
成员变量：有默认值
局部变量：没有默认值，必须定义，赋值，然后才能使用。否则：The local variable number(变量名) may not have been initialized

class Variable{
	//成员变量
	int num = 10;
	public void show(){
		int num2 = 20;//局部变量
	}
}

局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则

2:类作为形式参数的问题?

(1)如果你看到一个方法需要的参数是一个类名，就应该知道这里实际需要的是一个具体的对象。

public class Demo1 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Demo d=new Demo();
		//形式参数是基本类型
		System.out.println(d.num(10, 20));
		//形式参数是引用类型
		StudentDemo sd = new StudentDemo();
		Student s = new Student();
		sd.method(s);
	}
}
class Student{
	public void show(){
		System.out.println("我爱学习");
	}
}
class StudentDemo{
	//形式参数是引用类型
	//如果看到了一个方法的形式参数是引用类型，这里需要的是该类的对象
	public void method(Student s){
		s.show();
	}
}
class Demo{
	public int num(int a,int b){
		return a+b;
	}
	
}

3:匿名对象
(1)没有名字的对象（是对象的一种简化形式）
(2)应用场景

A:调用方法，仅仅只调用一次的时候。

调用多次的时候不适合

好处：匿名对象调用完毕就是垃圾，可以被垃圾回收器回收

b:可以作为实际参数传递。

public class Demo1 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//带名字的调用
		Student s = new Student();
		s.show();
		s.show();//同一个对象调用两次方法
		//匿名对象
		//new Student();
		//匿名对象调用方法
		new Student().show();
		new Student().show();//两次调用，虽然结果相同，但是是不同的对象调用的
		System.out.println("-----------");
		//匿名对象作为实际参数传递
		StudentDemo sd = new StudentDemo();
		sd.show(new Student());
		
		new StudentDemo().show(new Student());
	}
}
class Student{
	public void show(){
		System.out.println("我爱学习");
	}
}
class StudentDemo{
	public void show(Student s){
		s.show();
	}
}

4:封装

(1)隐藏实现细节，提供公共的访问方式

(2)好处：
A:隐藏实现细节，提供公共的访问方式
B:提高代码的复用性
C:提高代码的安全性
(3)设计原则
把不想让外界知道的实现细节给隐藏起来，提供公共的访问方式
(4)private是封装的一种体现。
封装：类，方法，private修饰成员变量

/*
 定义一个学生类
 	成员变量：name,age
 	成员方法：show()方法
 我们在使用这个案例的过程中，发现了一个问题：
 	通过对象去给成员变量赋值，可以赋值一些非法的数据，是不合理的
 	应该是在赋值之前，先对数据进行判断
 	判断在哪里做比较合适
 	StudentDemo类是一个测试类，测试类一般只创建对象，调用方法
 	所以，判断应该在Student类中
 	而我们在成员变量的位置不可以判断（做数据校验必须依靠逻辑语句）
 	逻辑语句应该定义在方法中
 	所以，在Student类中提供一个方法用来校验
 	给出方法 setAge()方法，如果不调用，就不能起到作用
 	应该要求必须使用方法，不能直接调用成员变量赋值
 		针对此种情况，java就提供了一个关键字：private
 	private：私有的，java修饰成员变量和成员方法
 		被private修饰的成员，只能在本类中访问
 	此为封装的思想：隐藏对象的属性和实现细节，仅对外提供公共访问方式
 	
 */
public class Demo1 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Student s = new Student();
		s.show();
		System.out.println("---------------------------------");
		s.name="Lily";
		//s.age=23; //使用private后，不能直接访问
		s.show();
		System.out.println("---------------------------------");
		//s.age=-23;
		//通过方法给值
		s.setAge(-23);//返回错误信息，保存上一个值
		s.show();
		System.out.println("---------------------------------");
		
		
	}
}
class Student{
	String name;
	private int age;
	public void show(){
		System.out.println("姓名"+name);
		System.out.println("年龄"+age);
	}
	//写一个方法进行校验
	public void setAge(int a){
		if(a<0||a>120){
			System.out.println("你给的年龄有问题");
		}
		else
			age =a;
	}
}

5:private关键字
(1)私有的意义，是一个权限修饰符，可以修饰成员变量和成员方法
(2)特点：

被private修饰的后的成员只能在本类中被访问

public class Demo1 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		PrivateDemo pd = new PrivateDemo();
		//不能访问私有的成员变量:The field PrivateDemo.num is not visible
		//System.out.println(pd.num);
		pd.show();
		//不能访问私有的成员方法:The method method() from the type PrivateDemo is not visible
		//pd.method();
		pd.function();
	}
}
class PrivateDemo{
	private int num = 10;
	public void show(){
		System.out.println(num);
	}
	private void method(){
		System.out.println("method");
	}
	public void function(){
		method();
	}
}

(3)private的应用：
把所有的成员变量给private了
提供对应的getXxx()/setXxx()方法

public class Demo1 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Student s = new Student();
		System.out.println("年龄是："+s.getAge()+"\t 姓名是："+s.getName());
		s.setAge(23);
		s.setName("lily");
		System.out.println("年龄是："+s.getAge()+"\t 姓名是："+s.getName());
	}
}
class Student{
	private String name;
	private int age;
	public int getAge(){
		return age;
	}
	public void setAge(int a){
		age =a;
	}
	public String getName(){
		return name;
	}
	public void setName(String n){
		name = n;
	}
}

6:this关键字
(1)代表当前类的引用对象（代表当前类的一个对象）
记住：哪个对象调用方法，该方法内部的this就代表那个对象
(2)this的应用场景：
A:解决了局部变量隐藏成员变量的问题。
B:其实this还有其他的应用。

	public int getAge(){
		return age;
	}
	public void setAge(int age){
		this.age = age;
	}
	public String getName(){
		return name;
	}
	public void setName(String name){
		this.name = name;
	}

this关键字内存图解

7:构造方法

(1)作用：用于对对象的数据进行初始化
(2)格式：
A:方法名和类名相同
B:没有返回值类型，连void都不能有
C:没有返回值

思考题：构造方法中可不可以有return语句呢?
可以。而是我们写成这个样子就OK了：return;

其实，在任何的void类型的方法的最后你都可以写上：return;

(3)构造方法的注意事项
A:如果我们没写构造方法，系统将提供一个默认的无参构造方法
B:如果我们给出了构造方法，系统将不再提供默认构造方法
如果这个时候，我们要使用无参构造方法，就必须自己给出。
推荐：永远手动自己给出无参构造方法。
(4)给成员变量赋值的方式
A:setXxx()
B:带参构造方法

public class Demo1 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Student s = new Student();
		System.out.println(s);//Student作为标记的地址值：Student@1a12fc0
		Student s1 = new Student("lily");
		System.out.println(s1.getName());
		Student s2 = new Student(23);
		System.out.println(s2.getAge());
	}
}
class Student{
	private String name;
	private int age;
	public int getAge(){
		return age;
	}
	public void setAge(int age){
		this.age = age;;
	}
	public String getName(){
		return name;
	}
	public void setName(String name){
		this.name = name;
	}
	public Student(){  //默认的数据初始化
		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;
	}
}

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

9:面向对象的练习题
(1)标准的手机类的定义和测试
(2)Demo类有求和方法，Test类进行测试。
什么时候定义成员变量?

当该变量是用来描述一个类的时候。那么，该变量就应该定义为成员变量

变量到底定义在哪里好呢？

变量的范围越小越好，因为能及时的被回收

(3)长方形案例

import java.util.Scanner;


public class Demo1 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入长");
		int length = scan.nextInt();
		System.out.println("请输入宽");
		int width = scan.nextInt();
		Rectangle re = new Rectangle();
		re.setLength(length);
		re.setWidth(width);
		System.out.println("周长为："+re.getGirth());
		System.out.println("面积为："+re.getArea());
	}
}
class Rectangle{
	private int length;
	private int width;
	public int getLength() {
		return length;
	}
	public void setLength(int length) {
		this.length = length;
	}
	public int getWidth() {
		return width;
	}
	public void setWidth(int width) {
		this.width = width;
	}
	public Rectangle(){
		
	}
	//求周长
	public int getGirth(){
		return (length+width)*2;
	}
	//求面积
	public int getArea(){
		return length*width;
	}
}

(4)员工案例

public class Demo1 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Employee emp = new Employee();
		emp.setEmployeeId("CUST1113");
		emp.setName("lily");
		emp.setAge(23);
		emp.show();
	}
}
class Employee{
	private String employeeId;
	private String name;
	private int age;
	public Employee(){
		
	}
	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 String getEmployeeId(){
		return employeeId;
	}
	public void setEmployeeId(String employeeId){
		this.employeeId=employeeId;
	}
	public void show(){
		System.out.println("员工编号是："+employeeId+"的这个人是："+name+"的年龄是："+age);
	}
}

(5)MyMath案例(自己提供加减乘除并测试)

import java.util.Scanner;


public class Demo1 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MyMath mm = new MyMath();
		Scanner scan = new Scanner(System.in);
		System.out.println("输入第一个数");
		int firstnumber = scan.nextInt();
		System.out.println("输入第二个数");
		int secondnumber = scan.nextInt();
		System.out.println("加法结果"+mm.add(firstnumber, secondnumber));
		System.out.println("乘法结果"+mm.mul(firstnumber, secondnumber));
		System.out.println("减法结果"+mm.sub(firstnumber, secondnumber));
		System.out.println("除法结果"+mm.div(firstnumber, secondnumber));	
	}
}
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;
	}
}

10:static关键字（针对多个对象有共同的成员变量值，修饰的数据是被所有人共享的）
(1)静态的意思：可以修饰成员变量和成员方法。
(2)静态的特点：
A:随着类的加载而加载
B:优先与对象存在
C:被类的所有对象共享
这其实也是我们判断该不该使用静态的依据。
D:可以通过类名调用
既可以通过对象名调用，也可以通过类名调用，建议通过类名调用。
(3)静态的内存图

静态的内容在方法区的静态区

(4)静态的注意事项；

A:在静态方法中没有this对象

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

静态比对象先存在

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

静态方法：

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

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

非静态方法：

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

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

(5)静态变量和成员变量的区别
A:所属不同
静态变量：属于类，类变量
成员变量：属于对象，对象变量，实例变量
B:内存位置不同
静态变量：方法区的静态区
成员变量：堆内存
C:生命周期不同
静态变量：静态变量是随着类的加载而加载，随着类的消失而消失
成员变量：成员变量是随着对象的创建而存在，随着对象的消失而消失
D:调用不同
静态变量：可以通过对象名调用，也可以通过类名调用
成员变量：只能通过对象名调用
(6)main方法是静态的
public:权限最大。由于main方法是被JVM调用，所以权限要够大
static:不用创建对象调用，通过类名就可以，方便JVM的调用
void:方法的返回值是反给调用者，返回值给jvm没有意义
main:就是一个常见的名称。

String[] args:字符串数组，可以接收数据，提供程序的灵活性

早期是为了接受键盘录入的数据的

格式：java MainDemo hello world java

public class Demo1 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(args);//[Ljava.lang.String;@1e6385e
		System.out.println(args.length);//0
		System.out.println(args[0]);//Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 0
	}
}