类与对象---对象

一、什么是对象？
1.对象是由我们自己创建的类来创建出来的。
2.对象就是类的实例【可以真正使用类的数据，可以调用类中元素的数据】
3.一个类可以创建出多个对象
二、如何创建对象？
1.保证用来创建对象的类是存在
2.需要通过类中提供的构造方法创建对象
格式 ： new 构造方法( [参数值] );

public class Person{
	public Person(){
		System.out.println("Person类无参数构造方法");
	}
	public Person(String value){

		System.out.println("Person 类有参数构造方法，参数是---value=="+value);
	}
	
}

public class Test1{
	public static void main(String args[]){
	//创建Person类的对象
	//格式：new 构造方法([参数值])
	//new Person();	//Person 类对象
	//new Person("javase")
	//为了以后方便适用对象，我们就把这个对象保存在变量
	Person per1 = new Person();
	}
}

三、创建好的对象的有何作用？
创建好的对象可以访问/调用类中的元素【变量/方法】，至于创建好的对象可以访问/调用类中的那些元素，那些元素不能访问/调用，就得看类中元素的访问限制修饰符。
四、对象的具体用法
变量的访问
1.实例变量—【对象.实例变量】
2.静态成员变量–【对象.静态成员变量/类名.静态成员变量】
以上的访问是在public修饰符的作用下操作的。
例如:

public class Student{
	//实例变量
	public int stuid=1001;
	public int stuage;
	public static String stuname = "zhangsan";
	public static String stuaddress;
}

public class Test2{
	public static void main(String args[]){
	//访问实例变量---【对象.实例变量】
	//创建Student 类的对象
	Student stu1 = new Student();
	System.out.println("stuage=="+stu1.stuage);
	//访问类变量--【对象.类变量/类名.类变量】
	stu1.stuage=23;
	System.out.println("stuage=="+stu1.stuage);
	//访问类变量---【对象。类变量/类名.类变量】
	Student stu2 = new Student();
	System.out.println("stuname=="+stu2.stuname);
	System.out.println("stuname=="+Student.stuname);
	//stu2.stuaddress="西安";
	//System.out.println("stuaddress=="+stu2.stuaddress);
	//System.out.println("stuaddress=="+Student.stuaddress);
	stu2.stuaddress="北京";
	System.out.println("stuaddress=="+stu2.stuaddress);
	System.out.println("stuaddress=="+Student.stuaddress);
	}
}

方法的访问
1.构造方法—new 构造方法();
2.实例方法–【对象.实例方法】
3.静态方法–【对象.静态方法/类名.静态方法】
例如:

public  class  Dog{
	//实例方法
	public  void  dogTest1(){
		System.out.println("Dog类中的实例方法");
	}
	//类方法
	public  static  void  dogStatic(){
		System.out.println("Dog类中的类方法");
	}
}

public class Test3{
	public static void main(String args[]){
	//实例方法---【对象.实例方法】
	Dog dog1= new Dog();
	dog1.dogTest1();
	//静态方法--【对象.静态方法/类名.静态方法】
	Dog dog2=new Dog();
	dog2.dogStatic();
	Dog.dogStatic();
	}
}

有参数的方法访问，需要注意的是参数的传递
例如：

public  class  Cat{
	//实例方法
	public void catTest1(int age,double height){
		System.out.println("Cat类中的实例方法--参数 1--age=="+age+"参数2--height=="+height);
	}
	//类方法
	public static void catStatic(Dog dog){
		System.out.println("Cat类中的类方法--参数--dog=="+dog);
	}
	
}

public class Test4{
	public static void main(String args[]){
	//实例方法---【对象.实例方法】
	Cat cat1= new Cat();
	cat1.catTest1(4,11.5);
	//静态方法--【对象.静态方法/类名.静态方法】
	Cat.catStatic(new Dog());
	//上面的方法在调用的时候传递的参数是具体数据值
	//我们在访问的时候传递保存数据值得变量
	int age =3;
	double hei=6.5;
	cat1.catTest1(age,hei);
	Dog dog=new Dog();
	cat1.catStatic(dog);
	}
}

总结: 先看【有没有/有几个/什么类型】，再传【匹配类型/匹配个数/值【变量】】

有返回值的方法访问，需要注意的是接收方法的返回值结果【类型匹配】
例如：

public  class  Cat{

	//实例方法
	public  int catTest2(int  num1,double num2){
		int  res=0;
        res=(int)(num1+num2); 		
	    return res;
	}
	//类方法
        public static Student catStatic2(Dog dog){
		//return  new Student();
		Student  stu=new Student();
                return stu;
	}
}

public  class  Test4{
	public static  void  main(String args[]){
		//访问有返回值和参数的方法
		Cat  cat2=new Cat();
		int val=cat2.catTest2(12,12.5);	
		System.out.println("catTest2的运行结果=="+val);
		Student  stu=Cat.catStatic2(new Dog());
		System.out.println("catStatic2的运行结果=="+stu.stuid);
	}
}

总结：方法的调用【1.要什么，传什么；2.给什么，收什么】
五、.对象的内存分配原理
对象是通过类的构造方法创建
类是一种自定义的复合数据类型

六.类与对象的关系
类是创建对象的模板；对象是类的具体表现

七.静态成员变量【类变量】与实例变量的区别
区别:
静态成员变量【类变量】 实例变量
成员变量【全局变量】
有static 关键字修饰 没有static 关键字修饰
程序运行前分配数据的内存空间【早】 程序运行时分配数据的内存空间【晚】
可以在多个同类对象之间共享数据值 不能在多个同类对象之间共享数据值
可以使用对象访问,也可以类名访问 只能对象访问
例如：

public  class  bear{
	public String bearname="熊大";
	
}

public  class Test5{
	public static void main(String args[]){
		bear bear1=new bear();
		bear1.bearname="熊二";
		System.out.println("bear1=="+bear1.bearname);
		bear bear2=new bear();
		System.out.println("bear2=="+bear2.bearname);
	}
	
}
//熊二
 //熊大

实例变量的数据值是不能再同类对象之间共享。

public  class  bear{
	public static String bearname="熊大";
}
public  class  Test5{
	public static  void  main(String args[]){
		Bear  bear1=new bear();
		bear1.bearname="熊二";
		System.out.println("bear1=="+bear1.bearname);	
		
		Bear  bear2=new Bear();
		System.out.println("bear2=="+bear2.bearname);
	}
}	
//熊二
 //熊二

类变量的数据值是能在同类对象之间共享。