JAVASE基础6——类

                                                                                                     类和对象

4.1.类是什么？

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

为什么有复合数据类型？

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

1. 类--具有共同性质的一组事物的群体。  人类 [物以类聚人以群分]

 

在java中用来描述具有共同性质的一组事物的自定义复合数据类型---类。

复合数据类型的本质---【根据自己的需求制作自己需要的数据类型的模式/规则/公式】

4.2.如何编写一个Java类？

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

例如:

public  class   HelloWorld{

}

public---访问限制修饰符【对类的访问权限】

class---创建类的关键字【类的标志】

HelloWorld--类名【首字母大写】

{}----类体

格式:

访问限制修饰符   class   类名{}

例如：

public class Student{  }  

class  User{  } 

4.3.Java类体中可以编写什么？

描述一组事物的共同性质

杯子--名字

     形状

     大小

     颜色

     装东西

名字，形状，大小，颜色-----基本属性

装东西---基本功能

通过事物的基本属性和基本功能来描述具有共同性质的一组事物。

基本属性------变量

基本功能-----方法

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

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

4.4.Java类中变量的分类及其基本特征？

变量---保存数据

1.数据类型【不一定就是之前的基本数据类型，也有可能是自定义的复合数据类型】

2.变量名称【合法标识符--全字母小写】

3.初始值

4.作用域

按照在类中编写变量的位置划分：

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

1.可以使用访问限制修饰符,也可以不使用。

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

3.可以在本类中的任意一个方法中被使用

例如:

//格式:访问限制修饰符   class   类名{}

public  class  Test1{

         //类---描述具有共同性质的一组事物的群体的复合数据类型

         //描述具有共同性质的一组事物需要从两方面

         //描述具有共同性质的一组事物的基本属性---变量

         //描述具有共同性质的一组事物的基本功能---方法

         //类中的变量：

         //成员变量【全局变量】--- 类中方法外

         //1.可以使用访问限制修饰符,也可以不使用。

         //2.可以不用赋予初始值，系统自动赋予默认值，也可以根据需要自己设置一个初始值。

         //3.可以在本类中的任意一个方法中被使用

         public  String  name="张三";

         int  age   

   //方法1中使用成员变量【全局变量】

public  void  method1(){

                  System.out.println("name=="+name);

                  System.out.println("age=="+age)；

         }

1.        //方法2中使用成员变量【全局变量】

   public  void  method2(){
   		System.out.println("name=="+name);
   		System.out.println("age=="+age);
   	}	
   }
   

    

测试类:

public  class  TestMain{
	public  static void  main(String args[]){
		//测试Test1类中方法中访问成员变量
		//Test1 t1=new Test1();
		//调用Test1类中method1()
		//t1.method1();
		//t1.method2();
	}
}

局部变量-----------------------方法里/方法参数

1.不能使用访问限制修饰符。

2.必须设置初始值

3.只能在本方法中使用。

例如:

//格式:访问限制修饰符   class   类名{}

public  class  Test2{

         //类---描述具有共同性质的一组事物的群体的复合数据类型

         //描述具有共同性质的一组事物需要从两方面

         //描述具有共同性质的一组事物的基本属性---变量

         //描述具有共同性质的一组事物的基本功能---方法

         //类中的变量：

         //局部变量----类中方法里/方法的参数

         //1.不能使用访问限制修饰符。

         //2.必须设置初始值

         //3.只能在本方法中使用。

         //方法1        

public  void  method1(){

                  //1.不能使用访问限制修饰符。

                  //public  String name="zhangsan";

                  String name="zhangsan";

                  //2.必须设置初始值

                  //int  age;

                  int  age=0;

                  System.out.println("在本方法中访问定义在方法中的局部变量");

                  //3.只能在本方法中使用

                  System.out.println("name=="+name);

                  System.out.println("age=="+age);

         }

    //方法2

  public  void  method2(){

           System.out.println("在method1方法外的其他方法中访问定义在method1的局部变量");

           //3.只能在本方法中使用

           //System.out.println("name=="+name);

           //System.out.println("age=="+age);

         }

 //方法的参数也是局部变量

         public  void  method3(String  name3,int age3){

           System.out.println("方法的参数也是局部变量");

           System.out.println("name3=="+name3);

           System.out.println("age3=="+age3);

         }



         //方法的参数也是局部变量

         //3.局部变量只能在本方法中使用

         public  void  method4(){

           //System.out.println("name3=="+name3);

           //System.out.println("age3=="+age3);

         }      

}

 

         //3.局部变量只能在本方法中使用

  public  void  method4(){

           //System.out.println("name3=="+name3);

           //System.out.println("age3=="+age3);

         }      

}

测试类

public  class  TestMain{

         public  static void  main(String args[]){

                  //测试Test2类中方法中访问局部变量

                  Test2  t2=new Test2();

                  //调用Test2类中method1()

                  t2.method1();

                  //调用Test2类中method3()

                  t2.method3("lisi",24);

         }

}

4.5.什么是成员变量的隐藏？

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

例如：

//成员变量的隐藏

//成员变量的名称与局部变量的名称相同

//局部变量的值会把成员变量的值隐藏

//注意:成员变量的隐藏与变量是什么数据类型没有关系，只看名称

public  class  Test3{

         //定义成员变量

         public String name="张三";

         public  void  method1(){

                  //定义局部变量

                  char name='B';

                  //成员变量的名称与局部变量的名称相同

                  //局部变量的值会把成员变量的值隐藏

                  System.out.println("name=="+name);//B

                  //如果需要访问被隐藏的成员变量的值，怎么办？

                  //通过this.成员变量的名称

                  System.out.println("this.name=="+this.name);//张三

         }

}

测试类

public  class  TestMain{

         public  static void  main(String args[]){

                  //测试Test3类中的成员变量的隐藏

                  Test3  t3=new Test3();

                  t3.method1();

         }

}

 

4.6.静态成员变量与实例变量的区别？

静态成员变量与实例变量----都是成员变量【全局变量】

1.可以使用访问限制修饰符,也可以不使用。

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

3.可以在本类中的任意一个方法中被使用

成员变量【全局变量】可以分为2种

按照成员变量【全局变量】是否使用static关键字

静态成员变量【类变量】---使用static关键字修饰的成员变量【全局变量】

实例变量---没有使用static关键字修饰的成员变量【全局变量】

static关键字---静态的---》提前分配存储数据的内存空间

没有使用static关键字修饰的元素，是在程序运行时分配存储数据的内存空间。

使用static关键字修饰的元素，是在程序运行前分配存储数据的内存空间。

例如：

//成员变量【全局变量】分类

//根据成员变量【全局变量】是否使用static关键字修饰

//1.使用static关键字修饰的成员变量【全局变量】---静态成员变量【类变量】

//2.没有使用static关键字修饰的成员变量【全局变量】---实例变量【普通的成员变量【全局变量】】

//只对成员变量【全局变量】与局部变量没有关系

//静态成员变量【类变量】与实例变量【普通的成员变量【全局变量】】都是成员变量【全局变量】

//所以静态成员变量【类变量】与实例变量都要符合成员变量【全局变量】的特征。

//1.可以使用访问限制修饰符,也可以不使用。

//2.可以不用赋予初始值，系统自动赋予默认值，也可以根据需要自己设置一个初始值。

//3.可以在本类中的任意一个方法中被使用

//静态成员变量【类变量】与实例变量的区别???

public  class  Test4{

         //实例变量--没有使用static--程序运行时---晚

         public  String name="zhangsan";

         //静态成员变量【类变量】--使用static---程序运行前---早

         public static  String address1="西安1"; //静态成员变量【类变量】

         static  String address2="西安1"; //静态成员变量【类变量】

         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  TestMain{

         public  static void  main(String args[]){

                  //测试Test4类中的静态成员变量

                  Test4  t4=new Test4();

                  //t4.method1();

                  t4.method2();

         }

}

区别:

静态成员变量【类变量】	实例变量
成员变量【全局变量】 1.可以使用访问限制修饰符,也可以不使用。 2.可以不用赋予初始值，系统自动赋予默认值，也可以根据需要自己设置一个初始值。 3.可以在本类中的任意一个方法中被使用
有static 关键字修饰	没有static 关键字修饰
程序运行前分配数据的内存空间【早】	程序运行时分配数据的内存空间【晚】
可以在多个同类对象之间共享数据值	不能在多个同类对象之间共享数据值
可以使用对象访问也可以使用类名访问	只能使用对象访问

例如：

public  class  Test5{

         //静态成员变量【类变量】

         public static  String name="zhangsan";

         //实例变量

         public String address="西安";

}

测试类

public  class  TestMain{

         public  static void  main(String args[]){

//静态成员变量【类变量】可以在多个同类对象之间共享数据值

                  //Test5  t5_1=new Test5(); //第一个对象

                  //Test5  t5_2=new Test5(); //第二个对象

                  //System.out.println("t5_1.name=="+t5_1.name);//zhangsan

                  //System.out.println("t5_2.name=="+t5_2.name);//zhangsan

                  //t5_1.name="lisi"; //通过第一个对象修改name静态成员变量【类变量】的值

                  //System.out.println("t5_1.name=="+t5_1.name);//lisi

                  //System.out.println("t5_2.name=="+t5_2.name);//lisi

                  //静态成员变量【类变量】是多个同类对象的公共变量。

                 

                  //实例变量不可以在多个同类对象之间共享数据值

                  //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_1=new Test5(); //第一个对象

                  //System.out.println("t5_1.name=="+t5_1.name);//zhangsan

                  //System.out.println("Test5.name=="+Test5.name);//zhangsan



                  //实例变量只能使用对象访问

                  Test5  t5_1=new Test5(); //第一个对象

                  System.out.println("t5_1.address=="+t5_1.address); //西安

                  //System.out.println("Test5.address=="+Test5.address);//错误

         }

}