Java的类和变量

一、类是什么？
       含义1：类--类型--数据类型--复合数据类型--自定义的复合数据类型。java提供的基本数据类型在实际的开发中是远远不够用的，所以就需要复合数据类型来补充。
       例如:我们现在要开发一个学生管理系统，光使用基本数据类型是不够的，因为基本数据类型只能表示年龄，身高，性别，学号....这些数据，所以我们需要一个学生数据类型。基本数据类型中没有学生类型，我们就需要自己创建出这个学生类型。我们自己创建的学生类型就属于复合数据类型---类。我们自己创建的学生类型就是一个学生类。

       含义2：类--类别--具有相同特征的一组事物集中起来就形成一个类别

       java中的类含义：通过java语言描述的一组具有相同特征的事物组成的自定义的复合数据类型

       java中的类是用来扩展java数据类型用的，往往都是我们自己定义的。类--描述现实事物的一个Java元素

二、如何编写一个 Java 类？

       通过class关键字来创建一个java类。class 是 java类的标志。

       格式:1.public  class 类名{}

                  public  class Student{} //创建一个学生类型
              2.class 类名{}
                 class  Teacher{} //创建一个教师类

       public/空白 --  访问限制修饰符【设置这个类那里能访问，那里不能访问】

        空白表示缺省限制修饰符

       class---关键字【创建类】
       类名----合法的标识符【与其他的类进行区分】
       首字母大写，如果由多个单词组成，每一个单词的首字母都要大写。
                                  Student   MyStudent
       {}------类体[类的身体]

三、Java类的类体可以编写什么？

   通过描述事物的基本信息和基本作用来完成对一个事物的简单描述。
          1.事物的---基本信息----属性---变量
          2.事物的---基本作用----功能---方法

四、Java 类中变量的分类及其基本特征？

   变量---就是程序运行过程中随时可能被修改的数据值，它的本质保存数据。由4个部分组成
          1.数据类型
          2.变量名称
          3.初始值
          4.作用域【有效范围】
   Java类中变量的分类：根据变量在类中的位置
          1.成员变量【全局变量】--定义在类中方法之外的位置
          2.局部变量--定义在方法中的或者方法的参数

成员变量基本特征：

         1.类中方法之外
         2.必须使用访问限制修饰符
         3.可以赋予初始值，可以不用给初始值，系统会给予默认值。
         4.当前类中任何一个方法中都可以使用

例：

package com.wanxing.test1;

public class MyClass {
    public int  testnumber=1001;
    //没有写是默认的缺省修饰符
    double testdouble;
    /**
     * 测试方法1
     */
    public void  testMethod1(){
        System.out.println("testMethod1方法---testnumber=="+testnumber);
        System.out.println("testMethod1方法---testdouble=="+testdouble);
    }
    /**
     * 测试方法2
     */
    public void  testMethod2(){
        System.out.println("testMethod2方法---testnumber=="+testnumber);
        System.out.println("testMethod2方法---testdouble=="+testdouble);
    }
}
    
package com.wanxing.test1;

public class TestMain {
    public static void main(String[] args) {
        //创建MyClass类的对象
        MyClass  mc1=new MyClass();
        System.out.println("testnumber=="+mc1.testnumber);//1001
        System.out.println("testdouble=="+mc1.testdouble);//0.0
        //调用测试方法
        mc1.testMethod1();
        mc1.testMethod2();
    }
}

局部变量的基本特征：
       1.在方法中或者方法的参数中
       2.不能使用访问限制修饰符（与成员变量的缺省限制符含义不一样）
       3.必须有初始值
       4.只能在当前方法中使用

例：

package com.wanxing.test1;

public class JuBuBianLiangClass {
    /**
     * 测试方法1
     */
    public  void  test1(){
        //public int  testnumber; //[错误]局部不能使用访问限制修饰符
        //空白表示没有修饰符
        //int  testnumber;
        //System.out.println("testnumber局部变量=="+testnumber); //[错误]局部变量必须有初始值
        //局部变量
        int  testnumber=1001;
        System.out.println("testnumber局部变量=="+testnumber); 
    }
    /**
     * 测试方法2
     */
    public  void  test2(){
        //局部变量只能在当前方法中使用，超出当前方法就不能使用
        System.out.println("test2方法中，访问test1方法中testnumber局部变量=="+testnumber); 
    }
}
成员变量的隐藏：若一个局部变量名称与一个成员变量名称相同，则局部变量将覆盖成员变量的值

例：

package com.wangxing.test3;
public class Teacher {
    //定义一个成员变量
    //成员变量可以在当前类中的任何一个方法中使用
    public  String  name="zhangsanfeng";
    
    //定义一个方法
    public  void  testMethod1() {
        //定义一个局部变量
        char name='家';
        //局部变量name将成员变量name的值"zhangsanfeng"给覆盖
        //因此输出的name变量的值是'家'而不是"zhangsanfeng"
        System.out.println("name--"+name); //家
        //如果需要强制使用被局部变量隐藏的成员变量的值，“this.成员变量的名称”
        System.out.println("String  name--"+this.name); //zhangsanfeng
    }
}
测试类
package com.wangxing.test3;
public class TestMain3 {
    public static void main(String[] args) {
        //创建Teacher类对象
        Teacher  t1=new Teacher();
        //通过Teacher对象调用testMethod1方法
        t1.testMethod1();
    }
}

成员变量划分：

      1.静态成员变量--------又叫类变量，使用static关键字修饰

      2.实例变量-------普通成员变量，没有使用static关键字修饰

      注：静态成员变量和实例变量都属于成员变量，都遵循成员变量的基本特征

静态成员变量和实例变量的区别：

      1.静态成员变量使用了static，实例变量没有使用static

      2.静态成员变量在一个类中多个对象之间可以共享数据，实例变量不能共享数据

      3.静态成员变量可以用类名或对象名调用，实例变量只能用对象名调用

      4.静态成员变量可以在静态方法中使用，实例变量不能在静态方法中使用

        原因是static关键字修饰的元素【变量和方法】，会在程序运行前分配好存储空间，没有使用static关键字修饰的元素【变量和方法】是在程序运行时候才分配存储空间。
        静态成员变量的内存分配程序运行前--早
        实例变量的内存分配程程序运行时----晚

例：

package com.wangxing.test;

public class TestClass {
    //定义一个成员变量
    //testname这个成员变量使用了static修饰--静态成员变量[类变量]
    public static String  testname="zhangsan";
    //testaddress这个成员变量没有static修饰--普通的成员变量--实例变量
    public String  testaddress="西安";
}

package com.wangxing.test;
public class TestMain {
    public static void main(String[] args) {
        //创建TestClass类的第一个对象
        TestClass  tc1=new TestClass();
        //创建TestClass类的第二个对象
        TestClass  tc2=new TestClass();
        /*
        //静态成员变量可以在同一个类的多个对象之间共享数据
        System.out.println("对象1的--testname="+tc1.testname);//zhangsan
        System.out.println("对象2的--testname="+tc2.testname);//zhangsan
        System.out.println("-------------------------------");
        //修改第一个对象的testname为lisi
        tc1.testname="lisi";
        System.out.println("对象1的--testname="+tc1.testname);//lisi
        System.out.println("对象2的--testname="+tc2.testname); //lisi
        */
        
        /*
        //实例变量则不能共享数据。
        System.out.println("对象1的--testaddress="+tc1.testaddress);//西安
        System.out.println("对象2的--testaddress="+tc2.testaddress);//西安
        System.out.println("-------------------------------");
        //修改第一个对象的testaddress为北京
        tc1.testaddress="北京";
        System.out.println("对象1的--testaddress="+tc1.testaddress);//北京
        System.out.println("对象2的--testaddress="+tc2.testaddress); //西安
        */
        
        //静态成员变量既可以用对象调用也可以用类名调用
        /*
        TestClass  tc=new TestClass();
        System.out.println("对象调用静态成员变量--testname="+tc.testname);
        System.out.println("类名调用静态成员变量--testname="+TestClass.testname);
        */
        
        //实例变量只能对象调用
        TestClass  tc=new TestClass();
        System.out.println("对象调用实例变量--testaddress="+tc.testaddress);
        //System.out.println("类名调用实例变量--testaddress="+TestClass.testaddress);
        
    }
}