6.Java中的类和变量

1.类是什么

        1.类------类型------数据类型------复合数据类型------自定义复合数据类型

        基本数据类型就8种，在开发中远远不够，因此我们就需要一个可以根据自己的需求随时能够制作出一个自己需要的数据类型。

        2.将性质或特征相同的元素抽象出来的事物

        在java中用来描述具有性质或特征相同的元素抽象出来的自定义复合数据类型--------类

2.如何创建一个java类

        通过class关键字来创建一个java类

        格式：

public class 类名{
}

        public------访问修饰限制符

        class------创建类的关键字，是类的标志

        类名------首字母大写

        {}------类体，放的内容具有性质或特征相同的元素

        例如：

public class Student{}//任何地方都可以访问

class Person{}//只能被同一个包中的类访问，不写访问修饰限制符，不等于没有---缺省访问控制修饰符

3.java类体中可以编写什么？

        { }放的内容具有性质或特征相同的元素，具有性质或特征相同的元素是用来描述某一组事物。

        如何描述一个具体的事物？比如描述自己：

        名字，籍贯，年龄------------基本属性

        工作，兴趣爱好---------------基本功能

        从例子可以知道，我们在描述一个具体的事物时是通过从基本属性和基本功能开始的。

         基本属性-----变量，用来在类中描述事物的基本属性

        基本功能------方法，用来在类中描述事物的基本功能

4.java中的变量

        1.变量的本质就是保存数据

        2.变量的组成

        ①数据类型。可以是基本数据类型，也可以是自定义的复合数据类型；

        ②变量名称。字母都小写

        ③初始值

        ④作用域

        3.变量用来描述事物的基本属性

        4.变量一定定义在类中

        5.变量的分类：

        （1）全局变量【成员变量】------类中方法外

        ①可以使用访问限制修饰符（public），也可以不使用（缺省的控制访问限制修饰符）；

        ②可以不用赋予初始值，系统会自动赋予默认值，也可以根据需要自己设置一个初始值；

        ③可以在本类中的任意一个方法中使用。

例如：

public class Test1 {
     //成员变量也叫全局变量，在类中方法外
		public String name="思竞";//使用了访问限制修饰符
		int age;    //没有使用，系统会默认
    //方法1中使用成员变量
		public void method1(){
			System.out.println("name="+name);
			System.out.println("age="+age);
		}
    //方法2中使用成员变量
		public void method2(){
			System.out.println("name="+name);
			System.out.println("age="+age);
		}
}

        类只是一个抽象，类似一个模型，使用的时候，我们还需要往这个模型里面去添加东西，这个将类变成对象的过程，就叫做实例化。在java中，实例化对象就是通过new关键字来实现的。

        创建对象格式：

        类名 对象名 = new 类名（）；

        通过， 对象.属性 或 对象.方法调用对象结构

测试类：

public class TestMain {
	public static void main(String[] args) {
		//测试Test1类中方法中访问全局变量
			Test1 t1=new Test1();//创建对象
			//调用对象结构
			t1.method1();
			t1.method2();
		}
}

输出为：

         （2）局部变量------类中方法里

        ①不能使用访问限制修饰符；

        ②必须设置初始值；

        ③只能在本方法中使用。

例：

public class Test1{
	public void method1(){
		String name="思竞";//不能使用访问限制修饰符
		int age=18;//必须设置初始值
		System.out.println("name="+name);
		System.out.println("age="+age);
	}
	public void method2(){
		//System.out.println("name="+name);报错，name不共享
		//System.out.println("age="+age);报错，age不共享
	}
}

 测试类：

public class TestMain {
	public static void main(String[] args) {
		//测试Test1类中方法中访问局部变量
		Test1 t1=new Test1();//创建对象
		//调用对象结构
		t1.method1();
		t1.method2();
	}
}

 输出为：

 5.成员变量的隐藏

        在同一个类中成员变量与某一个方法中的局部变量的名称相同，此时当我们在方法中使用这个成员变量的时候，得到的结果是局部变量的值，此时方法中的局部变量把类成员变量的值隐藏 了，这就是成员变量的隐藏。

        如果需要在方法中使用被隐藏的成员变量的值，可以通过this.成员变量名称来调用。

例：

public class Test3 {
	//定义成员变量
	public String name="思竞";
		public void method1(){
			//定义局部变量
			char name='z';
			System.out.println("name="+name);//输出z
		    //需要输出被隐藏的成员变量值，用this.name
			System.out.println("name="+this.name);//输出思竞
	}	
}

测试类：

public class Test3Main {
	public static void main(String[] args) {
		Test3 t3=new Test3();
		t3.method1();
	}
}

输出：

 6.静态成员变量和实例变量

        静态成员变量和实例变量都是成员变量，静态成员变量是用static关键字修饰的；

        实例变量就是普通的成员变量，没有使用static关键字修饰的成员变量。

        实例变量：

            1.可以使用访问限制修饰符【public  缺省的{友好的}】
            2.可以不用赋予初始值，系统自动赋予默认值，也可以根据需要自己设置一个初始值。
            3.可以在本类中的任意一个方法中被使用
            4.只能被对象访问
            5.不能在同一个类对象之间共享数据值

        静态成员变量：

            1.可以使用访问限制修饰符【public  缺省的{友好的}】
            2.可以不用赋予初始值，系统自动赋予默认值，也可以根据需要自己设置 一个初始值。
            3.可以在本类中的任意一个方法中被使用
            4.可以被对象访问，也可以用类名访问
            5.能在同一个类对象之间共享数据值

例：

public class Test4 {
	//实例变量，没有使用static
	public String name="思竞";
	//静态成员变量，使用了static
	public static String address1="重庆";
	static String address2="西安";
	static int age;
	//方法1
	public void method1(){
		System.out.println("访问实例变量---name="+name);
		System.out.println("访问静态成员变量---address1="+address1);
		System.out.println("访问静态成员变量---address2="+address2);
		System.out.println("访问静态成员变量---age="+age);
		}
	//方法2
	public void method2(){
		System.out.println("访问实例变量---name="+name);
		System.out.println("访问静态成员变量---address1="+address1);
		System.out.println("访问静态成员变量---address2="+address2);
		System.out.println("访问静态成员变量---age="+age);
		}
}

测试类:

public class Test4Main {

	public static void main(String[] args) {
		Test4 t4=new Test4();
		t4.method1();
		t4.method2();

	}

}

输出为：

 两者区别：

        

 例：

public class Test5 {
	public String name="思竞";//实例变量
	public static String address="重庆";//静态成员变量
}

 测试类：

public class Test5Main {

	public static void main(String[] args) {
		//静态成员变量可以在多个同类对象之间共享数据
		Test5 t5_1=new Test5();//第一个对象
		Test5 t5_2=new Test5();//第二个对象
		System.out.println("t5_1.address="+t5_1.address);//重庆
		System.out.println("t5_2.address="+t5_2.address);//重庆
		//现在修改静态变量的值
		t5_1.address="西安";//通过第一个对象修改address静态成员变量的值
		//发现输出两个都是西安，因为静态成员变量在同类对象中共享数据值
		System.out.println("t5_1.address="+t5_1.address);//西安
		System.out.println("t5_2.address="+t5_2.address);//西安
		
		//实例变量不可以在多个同内对象之间共享数据值
		Test5 t5_3=new Test5();//第三个对象
		Test5 t5_4=new Test5();//第四个对象
		System.out.println("t5_3.name="+t5_3.name);//思竞
		System.out.println("t5_4.name="+t5_4.name);//思竞
		//现在修改实例变量的值
		t5_3.name="伟伟";//通过第一个对象修改name实例变量的值
		//发现t5_3是伟伟，t5_4还是之前的思竞，因为实例变量在同类对象中不共享数据值
		System.out.println("t5_3.name="+t5_3.name);//伟伟
		System.out.println("t5_4.name="+t5_4.name);//思竞
		
		//静态成员变量可以使用对象访问也可以使用类名访问
		Test5 t5_5=new Test5();
		System.out.println("t5_5.address="+t5_5.address);//西安
		System.out.println("Test5.address="+Test5.address);//西安
		//实例对象只能使用对象访问
		Test5 t5_6=new Test5();
		System.out.println("t5_6.name="+t5_6.name);//思竞
		//System.out.println("Test5.name="+Test5.name);报错
		
	}

}

 输出为：