11.对象的具体用法

对象是用来在其他类中调用创建对象类中的变量和方法
需要2个类

第一个类：创建对象的java类
           【实例变量  静态成员变量 和构造方法  实例方法  静态方法】

package com.javatest.a;
	//对象的具体用法
public class Testa {
	//需要2个类
	//第一个类需要拥有：实例变量  静态成员变量  构造方法 实例方法 静态方法
	//第二个类：其他类
	//在其他类的构造方法、实例方法、静态方法使用第一个java类中的变量
	/*
	 在其它类的狗崽方法、实例方法和静态方法使用创建对象的java类中的实例变量和静态成员变量
	 实例变量只能对象访问、静态实例变量可以对象访问和类名访问
	 */
	//创建对象的java类
	public String test1 = "实例变量";
	public static String test2 = "静态成员变量";
	
}

  第二个类：其他类
       我们可以在其他类中方法外【成员变量】,也可以在其他类中的构造方法、实例方法、静态方法中创建对象【局部变量】。
在其他类的构造方法、实例方法、静态方法使用创建对象的java类中变量
总结：在其他类的构造方法、实例方法、静态方法使用创建对象的java类中的实例变量和静态成员变量，实例变量只能对象访问，静态成员变量既可以对象访问也可以类名访问。
 

package com.javatest.a;
	//其他类
public class Testb {
	//创建对象
	public Testa t1 = new Testa();
	//构造方法
	public Testb(){
		//其它类中构造方法可以创建对象
		Testa t2 = new Testa();
		//其他类中的构造方法中使用Testa类的实例变量
		//访问实例变量
		//赋值格式：对象.实例变量名称=数据值
		t1.test1="Teata中实例变量";
		t2.test1="Teata中实例变量";
		//取值格式“对象.实例变量名称
		System.out.println("Testa类中的实例变量1"+t1.test1);
		System.out.println("Testa类中的实例变量1"+t2.test1);
		
		//其它类中构造方法使用Testa类的静态成员变量
		//赋值格式：对象.静态成员变量=数据值 /类名.静态成员变量=数据值
		t1.test2="对象调用Testa类中的静态成员变量";
		t2.test2="对象调用Testa类中的静态成员变量";
		Testa.test2="类名调用Testa类中的静态成员变量";
		//取值格式：对象.实例变量名称 / 类名.静态成员变量
		System.out.println("对象调用Testa类中的静态成员变量"+t1.test2);
		System.out.println("对象调用Testa类中的静态成员变量"+t2.test2);
		System.out.println("类名调用Testa类中的静态成员变量"+Testa.test2);
	}
	
	//实例方法
	public void testc(){
		//创建局部变量
		Testa t3 = new Testa();
		//访问实例变量
		//赋值格式：对象.实例变量名称= 数据值
		t1.test1="实例方法赋值";
		t3.test1="实例方法赋值";
		//取值格式：对象.实例变量名称
		System.out.println("Testa类中的实例变量=="+t1.test1);
		System.out.println("Testa类中的实例变量=="+t3.test1);
		
		//访问Testa类中的静态成员变量
		//赋值格式：对象.静态成员变量=数据值  /类名.静态成员变量=数据值
		t1.test2="利用对象调用Testa类中的静态成员变量";
		t3.test2="利用对象调用Testa类中的静态成员变量";
		Testa.test2="利用类名调用Testa类中的静态成员变量";
		//取值格式：对象.实例变量名称 /类名.静态成员变量
		System.out.println("对象调用Testa类中的静态成员变量"+t1.test2);
		System.out.println("对象调用Testa类中的静态成员变量"+t3.test2);
		System.out.println("类名调用Testa类中的静态成员变量"+Testa.test2);
	}
	//静态方法
	public static void testd(){
		//创建局部变量
		Testa t4 = new Testa();
		//访问实例变量
		//赋值格式:对象.实例变量名称=数据值
		t4.test1="实例方法的赋值";
		//取值格式:对象.实例变量名称
		System.out.println("Testa类中的实例变量=="+t4.test1);
		
		//访问静态成员变量
		//赋值格式：对象.静态成员变量=数据值 /类名.静态成员变量=数据值
		t4.test2="静态成员变量";
		Testa.test2="静态成员变量";
		//取值格式:对象.实例变量名称/类名.静态成员变量
		System.out.println("对象调用Testa类中的静态成员变量="+t4.test2);
		System.out.println("类名调用Testa类中的静态成员变量="+Testa.test2);
	}
	
}

 

在其他类的构造方法、实例方法、静态方法使用创建对象的java类中方法

在其他类的构造方法、实例方法、静态方法使用创建对象的java类中的构造方法、实例方法、静态方法,
构造方法通过new+构造方法()，实例方法只能对象访问，静态方法既可以对象访问，也可以类名访问。

package com.javatest.b;
//在其他类的构造方法、实例方法、静态方法使用创建对象的java类中的构造方法、实例方法、静态方法
public class Testd {
	//创建对象
	Testc tw = new Testc();//成员变量
	//构造方法
	public Testd(){
		//其他类的实例方法中使用创建对象的java类中的构造方法
		//格式：【new 构造方法()】
		Testc tx = new Testc();
		//其他类的实例方法中使用创建对象的java类中的实例方法
		//格式：【对象.实例方法()】
		tw.test11();
		tx.test11();
		//其他类的实例方法中使用创建对象的java类中的静态方法
		//格式：【对象.静态方法()/类名.静态方法()】
		tw.test21();
		tx.test21();
		Testc.test21();
		
		//构造方法参数的传递
		//1.传递变量--将参数定义成变量
		//把变量传递给方法的参数
		String  name = "zhangsan";
		Testc tx1 = new Testc(name);
		//2.传递数据值--将具体数据值直接设置给方法的参数
		Testc tx2 = new Testc("lisi");
		
		//实例方法参数的传递
		//1.传递变量--将参数定义成变量
		//把变量传递给方法的参数
		String  name1 = "wangwu";
		tw.test12(name1);
		//2.传递数据值--将具体数据值直接设置给方法的参数
		tw.test12("wangliu");
		
		//静态实例方法参数的传递
		//1.传递变量--将参数定义成变量
		//把变量传递给方法的参数
		String  name2 = "小八";
		tw.test22(name2);
		tx.test22(name2);
		Testc.test22(name2);
		//2.传递数据值--将具体数据值直接设置给方法的参数
		tw.test22("秘制小汉堡");
		tx.test22("秘制小汉堡");
		Testc.test22("秘制小汉堡");
	}
	
	//实例方法
	public void testy(){
		//其他类的实例方法中使用创建对象的java类中的构造方法
		//格式【new 构造方法()】
		Testc ty = new Testc();//局部变量
		//其他类的实例方法中使用创建对象的java类中的实例方法
		//格式：【对象.实例方法()】
		tw.test11();
		ty.test11();
		//其他类的实例方法中使用创建对象的java类中的静态方法
		//格式：【对象.静态方法()/类名.静态方法()】
		tw.test21();
		ty.test21();
		Testc.test21();
		
		//构造方法参数的传递
		//1.传递变量--将参数定义成变量
		//把变量传递给方法的参数
		String  name = "zhangsan";
		Testc tx1 = new Testc(name);
		//2.传递数据值--将具体数据值直接设置给方法的参数
		Testc tx2 = new Testc("lisi");
		
		//实例方法参数的传递
		//1.传递变量--将参数定义成变量
		//把变量传递给方法的参数
		String  name1 = "wangwu";
		tw.test12(name1);
		//2.传递数据值--将具体数据值直接设置给方法的参数
		tw.test12("wangliu");
		
		//静态实例方法参数的传递
		//1.传递变量--将参数定义成变量
		//把变量传递给方法的参数
		String  name2 = "小八";
		tw.test22(name2);
		ty.test22(name2);
		Testc.test22(name2);
		//2.传递数据值--将具体数据值直接设置给方法的参数
		tw.test22("秘制小汉堡");
		ty.test22("秘制小汉堡");
		Testc.test22("秘制小汉堡");
		
	}
	
	//静态方法
	public static void testz(){
		//其他类的实例方法中使用创建对象的java类中的构造方法
		//格式：【new 构造方法()】
		Testc tz = new Testc();
		//其他类的实例方法中使用创建对象的java类中的实例方法
		//格式：【对象.实例方法()】
		tz.test11();
		//其他类的实例方法中使用创建对象的java类中的静态方法
		//格式：【对象.静态方法()/类名.静态方法()】
		tz.test21();
		Testc.test21();

		//构造方法参数的传递
		//1.传递变量--将参数定义成变量
		//把变量传递给方法的参数
		String  name = "zhangsan";
		Testc tx1 = new Testc(name);
		//2.传递数据值--将具体数据值直接设置给方法的参数
		Testc tx2 = new Testc("lisi");
		
		//实例方法参数的传递
		//1.传递变量--将参数定义成变量
		//把变量传递给方法的参数
		String  name1 = "wangwu";
		tz.test12(name1);
		//2.传递数据值--将具体数据值直接设置给方法的参数
		tz.test12("wangliu");
							
		//静态实例方法参数的传递
		//1.传递变量--将参数定义成变量
		//把变量传递给方法的参数
		String  name2 = "小八";
		tz.test22(name2);
		Testc.test22(name2);
		//2.传递数据值--将具体数据值直接设置给方法的参数
		tz.test22("秘制小汉堡");
		Testc.test22("秘制小汉堡");
		
		
		//实例方法的返回值
		String canshu1 = "法外狂徒";
		String qwe1=tz.test13(canshu1);
		System.out.println("test13的结果为--"+qwe1);
		
		//静态方法的返回值
		String canshu2 = "信条";
		String qwe2=tz.test23(canshu2);
		System.out.println("test23的结果为--"+qwe2);
		
		
	}
	
	

}

关于方法参数的传递

1.传递变量【传递引用】--将参数定义成变量，把变量设置给方法的参数
2.传递具体数据值【传递值】--将具体的数据值直接设置给方法的参数

 

//构造方法参数的传递
//1.传递变量【传递引用】--将参数定义成变量，把变量设置给方法的参数
String canshu1="zhangsan";
Person personcanshu1=new Person(canshu1);
//2.传递具体数据值【传递值】--将具体的数据值直接设置给方法的参数
Person personcanshu2=new Person("张三");
		
//实例方法参数的传递
//1.传递变量【传递引用】--将参数定义成变量，把变量设置给方法的参数
String canshu2="zhangsan";
person1.shiliMethod2(canshu2);	
//2.传递具体数据值【传递值】--将具体的数据值直接设置给方法的参数
person2.shiliMethod2("张三");
		
//静态方法参数的传递
//1.传递变量【传递引用】--将参数定义成变量，把变量设置给方法的参数
String canshu3="zhangsan";
person1.staticMethod2(canshu3);
//2.传递具体数据值【传递值】--将具体的数据值直接设置给方法的参数
Person.staticMethod2("张三");

 

理解：1.看【看方法有没有参数，有几个，什么类型】
           2.传【传递变量/传递值】

关于方法的返回值

调用有返回值的方法时，需要使用方法返回值类型对应的变量来接收方法结果。

对象的具体用法:
    1.实例变量只能对象访问，静态成员变量既可以对象访问也可以类名访问。
    2.构造方法通过new+构造方法()，实例方法只能对象访问，静态方法既可以对象访问，也可以类名访问。
    3.要什么，给什么;给什么，收什么