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

落日映苍穹つ 2022-09-30 10:50 107阅读 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关键字内存图解

![Center][]

**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变量。

![Center 1][]

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)静态的内存图

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

![Center 2][]

(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
    	}
    }

[Center]: /images/20220706/f06c926fe91443f484c8d2ae11b532ed.png
[Center 1]: /images/20220706/0817e653a70d4ea29fe0fc1c90530c4a.png
[Center 2]: /images/20220706/055170f14e614118852c01481c6ae907.png