JAVA 5 类与对象初级

一.类与对象关系

• 类就是数据类型。
• 对象就是一个具体的实例。

//创建Cat类的实例对象
Cat cat1 = new Cat();
cat1.name = "小白";
cat1.age = 8;
cat1.color = "白";

//打印
System.out.println("第一只猫信息" + cat1.name);


//定义类，及自定义了一个数据类型Cat
class Cat  
{
    String name;
    int age;
    String color;
}

二.属性/成员变量

• 成员变量=属性=filed（字段），可以是基本数据类型，也可以是引用类型（对象，数组）。
• 属性如果不赋值会有默认值（局部变量不赋值、不会有默认值），具体int short byte long float double默认值都为0,char默认\u0000,boolean默认false,String默认NULL。

三.类与对象的内存分配机制

   java数据结构分析

•  栈：一般存放基本数据类型（局部变量）。

• 堆：存放对象（Cat cat1,数组等）。

• 方法区：常量池（常量，比如字符串）+类加载信息。

   类与对象内存分配 

1. 先加载Person类信息（属性和方法信息，只会加载一次）。
2. 在堆中分配空间，进行默认初始化。
3. 把地址赋给p，p就指向对象。
4. 进行指定初始化。

Person p = new Person();
p.name = "jack";
p.age = 10;

四 .类的成员方法

1.访问修饰符，作用是控制方法使用范围，如果不写默认访问（有四种：public,protected,默认，private）。

2.返回类型可以是任意类型，包括基本类型和引用类型。

3.一个方法最多有一个返回值，若想返回多个值可以使用数组。

4.方法命名采用驼峰命名，如：getSum。

AA a = new AA();  //创建AA类的对象a
int[] res = a.getSumAndSub(1,4);  //类的成员方法使用
System.out.println("和=" + res[0]);
System.out.println("差=" + res[1]);

class AA
{
    public int[] getSumAndSub(int a,int b)
        {
             int[] resArr = new int[2];
             resArr[0] = n1 + n2;
             resArr[1] = n1 - n2;
             return resArr;
        }
}

五.方法的内存分配机制

六.方法传参

1. 基本数据类型传的都是值 ，形参不改变实参。

2. 引用类型（数组，对象）传的是地址（类似c语言中传指针）。当在方法中将传入的对象p=NULL或p = new 方法名时，不会改变原来的对象。

七.方法重载

1.介绍：java中允许同一个类中，多个同名方法的存在，但要求形参列表不一致。

2.好处：减轻了起名和记名的麻烦。

public class cha62
{
	public static void main(String[] args)
	{
		T t = new T();
		System.out.println(t.cal(10,10));//20
		System.out.println(t.cal(10,10.3));//20.3

	}
}

class T
	{
		public int cal(int n,int m)
		{
			return n + m;
		}
		public double cal(int n,double m)
		{
			return n + m;
		}
	}

 八.可变参数

1. 介绍：java允许一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。
2. 基本语法:访问修饰符 返回类型 方法名（数据类型... 形参名）。 

细节：

• 可变参数的实参可以为0个和任意个。
• 可变参数实参可以为数组。

int arr[] = {1,2,3};
T t = new T();
t.sum(arr);

class T
{
    public int sum(int... nums);
    {
        System.out.printf("可变参数的长度=" + nums.length);//3
    }
    
}

• 可变参数本质是一个数组。
• 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后。
• 一个形参列表中只能有一个可变参数。

public class cha63
{
	public static void main(String[] args)
	{
		T t = new T();
		System.out.println(t.sum(10,10,100));//120
	}
}

class T
	{
		//int...表示接收的是可变参数，类型为int。
		public int sum(int... nums)
		{
			//nums已变为数组
			System.out.println("接收的参数个数为=" + nums.length);//3
			int res = 0;
			for(int i = 0;i<nums.length;i++)
			{
				res += nums[i];
			}
			return res;
		}
	}

 九.构造器

• 构造方法又叫构造器，是类的特殊方法，主要作用是完成新对象的初始化。
• 构造器的修饰符可以默认，方法名和类名相同，没有返回值。
• 无参构造器可以默认所有对象的某一属性都为一固定值。

class Dog
{
    int age;
    public Dog()//默认对象age为18
    {
        age = 18;
    }

}

• 自己定义的构造器会覆盖默认的构造器，若还想使用默认构造器可自己重新定义一下。

Dog dog1 = new Dog("雄安");
Dog dog2 = new Dog();

class Dog
{
    String name;
    public Dog(String dname)//自己定义的构造器会覆盖默认
    {
        //...
    }
    Dog(){};//重新定义默认构造器
}

public class cha64
{
	public static void main(String[] args)
	{
		person t = new person("smith",80);
        person t = new person("smith");

	}
}

class person
	{
		int age;
		String name;
		public person(String pName,int pAge)
		{
			name = pName;
			age = pAge;
		}
	    public person(String pName)//只初始化姓名
		{
			name = pName;
		}
	}

 十.this关键字

• this关键字用于区分当前类的属性和局部变量。

T t = new T(10);
class T
{
    int age;
    public T(int age)
    {
        this.age = age;   //this.age代表当前类中的age可以区分局部变量age
    }
}

• this关键字访问成员方法：this.方法名（参数列表）。。

class T
{
    public void f1()
    {
        Ststem.out.println("f1()");
    }
    public void f2()
    {
        Ststem.out.println("f1()");
        //访问成员方法
        f1();  //第一种方式
        this.f1();  //第二种方式
    }


}

•  this关键字访问构造器：this(参数列表)；只能在构造器中使用，且放在第一句。

T t = new T();

class T()
{
    String name;
    int age;
    public T()
    {
        this("jack",100);//与目标构造器参数一致
        System.out.println("T()构造器");
    }
    public T(String name,int age)
    {
        System.out.print("T(String name,int age")构造器)；
    }
}

• this只能再类定义的方法中使用。