Java中的类

类

1.介绍类

        Java这门编程语言中，首当其冲一个概念就是类，到底什么是类呢，从第一天接触Java开始，一直在写，但却没真正研究过。

        类：它是一种抽象的概念。对于初学者来学不容易理解。它代表的是某一特殊的群体、或者是具备一定行为（功能）和属性事物。

        为了更好的理解到底什么是类，就从大家生活中的事物入手分析，并让大家慢慢形成概念，进而达到对类比较深刻的理解。

        在生活中经常会说到“车”、“人”、 “动物”等这样的词语。请大家想想，在说出这些词语的时候当时脑海里面想的是什么呢？

        这里就以“车”为例进行简单的分析：当说出“车”这个词的时候，也许很多人的脑海里面都会想当自己所熟悉的某个品牌，某个系列的车。而在和别人阐述的时候只是采用“车”这个词（字）将其描述而已。也就是说每个人说出的“车”都不一定相同，但都采用相同的字或词将其描述出来。

        那么“车”这个词（字）就是对生活中车这类事物一个概述，或者说抽象的总结。可以将“车”这个词看成是对车这类事物的一个统称。而实际生活中的每一辆车都是这个统称下的一个具体的实物。

        如果使用Java语言来代表我们人类的语言描述车这一特殊的事物和具体每一辆车这个实物，Java语言采用类class描述某一特殊事物，采用对象表示这一事物的具体每一个个体（实物）。

Java中的类有两层含义：

1.类--》类型-----》数据类型---》引用【复合】数据类型------》自己定义的引用【复合】数据类型

         类：自己定义的引用【复合】数据类型

         与使用基本类型的时候一样的格式来定义变量。

2. 类---》对具有共同性质的一组事物的集合/群体  【物以类聚】

Java中的类定义：

类--用java语言描述的具有共同性质的一组事物的集合/群体的自己定义的引用【复合】数据类型。

2.如何定义类

在Java中采用class关键字定义类。

定义类的格式：

修饰符  class   类名{

类中的内容

}

修饰符：目前我们只认识一种修饰符就是public [表示这个类可以在任何地方被访问]

class【关键字】：定义类的。【class就是类的标志】

类名：必须符合标识符的定义语法要求，同时还要满足如果是多个单词每个单词首字母大写。

{}：类体【类的身体】[将来我们所编写的java代码，都要书写在类体中]

例如：定义一个汽车类

/*

 * 演示定义类

 */

public class Car{

}

3.类中的成员

        通过上面的学习基本了解如何定义类，那么我们在上面的汽车类中有没有实际内容？

        通过class定义了一个类以后，这个类中是没有任何内容的，也就是说这个类是一个空的。

        接下来需要考虑的问题是，类体可以有什么内容？

        首先，我们已经知道了类就是一组具有公共性质的事物组合，那么我们是如何用语言类描述一个/一组事物？

        我们在描述一个/一组事物的时候通常会先描述这个事物的基本特征，然后在描述这个事物所具有的功能。

        从这个角度分析我们可以将语言类描述一个/一组事物的步骤总结成java语言，从而得到java类中可以有什么内容。

        我们的到的结论是：java类中要描述事物的基本特征，还要描述这个事物所具有的功能。

        在java类中用变量来描述事物的基本特征，用方法来描述这个事物所具有的功能。

4.类中的变量

        变量--程序运行过程中可能会随时变得数据。

        Java中用来保存数据的内存区域。

        变量的本质是保存数据。

        为什么需要变量类保存数据？

     在程序运行的时候，会需要用到很多的数据，可能这些数据比较复杂，比较大，会重复出现。当这些个比较复杂，比较大，会重复出现，那么我们就要不断的写出这些数据。这时我们就会做一些大量的重复性的工作，为了减少我们重复写数据的这个工作，我们就要想办法，把这些比较复杂，比较大的数据简化掉。这时我们就可以把这个比较复杂，比较大的数据保存在一个内存区域中，给这个内存区域起一个简短的名称，来代表这个比较复杂，比较大的数据，这时当重复使用数据的时候我们就可以使用这个简短的名称，这样就减少工作量。

如何定义变量？

1.一个变量的组成

       1.数据类型  ---  决定了变量的内存大小

       2.变量名称 --- 合法的标识符 【全小写】[zhang_san]

       3.初始值

       4.作用域【有效范围】

2. 定义格式：数据类型   变量名称;

 例如：  int   a;

             double  d;

             Student  stu;

3.变量赋格式： 【=】--从右向左

 变量名称 = 数据值；

 例如：a = 100;

            d = 12.5;

            stu   =  new Student();

4有的时候我们为了快速使用变量会把定义和赋值一起完成

          定义 +  赋值  ： 数据类型   变量名称 =  数据值；

          例如：int  a=100;

                     double d=12.5;

                     Student  stu=new Student();

5.在java类中我们按照变量出现的位置，将java类中的变量分成2类

   1.全局变量【成员变量】

          出现在java类中，除过方法之外的位置定义的变量就是全局变量【成员变量】

          1.1 可以没有初始值【系统会给与一个默认的初始值】

                基本数据类型

                       byte  short  int  long --- 0;

                       flaot  double  --  0.0

                       char  --  ‘’

                       boolean   --  false

                       其他的类型都是 null

         1.2 在本类中的所有方法中都可以使用这个变量

         1.3 位置要在类中，方法之外

    2.局部变量

           出现在类中，方法里面/方法的参数位置定义的变量就是局部变量

            2.1 不能有访问修饰符

            2.2 一定要有初始值

            2.3 只能在本方法中被使用。

            2.4 方法里/参数

6.将java类中的全局变量【成员变量】划分成2类

   语句在定义全局变量时有没有使用static关键划分

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

                       实际上实例变量就是普通的全局变量【成员变量】

                 具有全局变量【成员变量】

                  1.可以没有初始值【系统会给与一个默认的初始值】

                  2.在本类中的所有方法中都可以使用这个变量

                  3.位置要在类中，方法之外

                  4.在其他类中使用的时候需要使用对象访问

                  5.没有数据共享功能【该变量的值不能再多个对象之间被共享】

package com.click369.test.demo1;

public class Person {

     //定义了两个变量name/testvalue

    //name/testvalue---全局变量

    //name---没有static --  实例变量

    //testvalue---有static -- 静态成员变量【类变量】

      public  String  name;

      public  static  char   testvalue;

}

测试代码：

 //实例变量---在其他类中使用的时候需要使用对象访问

 //1.创建Person类的对象

 Person per=new  Person();

 //2.为Person类中的实例变量name赋值

 per.name="zhangsan";

 //3.访问name变量的值

System.out.println("实例变量name的数据值是==="+per.name);

//实例变量--没有数据共享功能

Person per1=new  Person();

per1.name="lisi";

System.out.println("实例变量name的数据值是==="+per1.name);  //lisi

Person per2=new  Person();

System.out.println("实例变量name的数据值是==="+per2.name);  //null

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

        1.可以没有初始值【系统会给与一个默认的初始值】

        2.在本类中的所有方法中都可以使用这个变量

        3.位置要在类中，方法之外

        4.在其他类中使用的时候可以用对象访问，也可以直接用类名访问

        5.有数据共享功能

package com.click369.test.demo1;

public class Person {

//定义了两个变量name/testvalue

//name/testvalue---全局变量

//name---没有static --  实例变量

//testvalue---有static -- 静态成员变量【类变量】

public  String  name;

public  static  char   testvalue;

}

测试代码：

//类变量--在其他类中使用的时候可以用对象访问，也可以直接用类名访问

/*对象访问

Person  per=new Person();

per.testvalue='家';

System.out.println("类变量testvalue的数据值是==="+per.testvalue);

*/

/*

//类名访问

Person.testvalue='园';

System.out.println("类变量testvalue的数据值是==="+Person.testvalue);

*/

//类变量---有数据共享功能

Person per1=new  Person();

per1.testvalue='国';

System.out.println("类变量testvalue的数据值是==="+per1.testvalue); //国

Person per2=new  Person();

System.out.println("类变量testvalue的数据值是==="+per2.testvalue); //国

7. 我们在java类中的定义变量的时候，可能会出现成员变量，与局部变量的名称一样啦。

    这种现象就是成员变量的隐藏--在同一个类中成员变量的名称与局部变量的名称一样。

    结果是当我们输出数据值的时候，这个数据值不再是原来的成员变量的数据值啦，而变成了局部变量的数据值。

    如果一定要得到被隐藏的成员变量的值需要使用this关键来访问。

package com.click369.test.demo2;

public class Student {

//成员变量

public String  name="zhangsan";   

public  void  testMethod(){

  //局部变量

  //局部变量的名称与成员变量的名称一样【成员变量的隐藏】

  //隐藏的是成员变量的值【局部变量的值把成变量的值覆盖】

  char  name='家';

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

  // 如果一定要得到被隐藏的成员变量的值需要使用this关键来访问

  System.out.println("被隐藏的成员变量的值==="+this.name); //zhangsan      

   }

}

测试代码：

//创建Student类的对象

Student  stu=new  Student();

stu.testMethod();

//创建Student类的对象

Student  stu=new  Student();

stu.testMethod();

5.类中的方法

       1. 方法--也叫函数【描述事物的功能/行为】

               一段用来实现某一项功能的java代码的集合。

               方法的定义：

                访问修饰符  返回值类型   方法名称(参数){

                          实现某一项功能的java代码

                 }  

               1.修饰符：目前只有public

               2.返回值类型：方法的执行结果 【没有结果也是结果的一种】

                      2.1 方法执行后没有结果的时候，方法的返回值是void，但是绝对不能不写。

                      2.2 方法的返回值类型是一种具体的数据类型【基本数据类型8中，引用数据类型】    

                      2.3 如果方法的返回值不是void，那么该方法的方法体中的最后一行一定要有return语言。

              3.方法名称：合法的标识符【首字母小写从第二个单词开始大写，尽量使用动词开始】

              4.():参数列表【可以有参数，也可以一个参数都没有】

                     参数：用来接收方法之外的数据值，进入本方法。【定义的变量】

              5.{}：方法体【包含实现一项功能的java代码】

package com.click369.test.demo3;

public class MyClass {

/*

  访问修饰符  返回值类型   方法名称(参数){

          实现某一项功能的java代码

       }

 */

public  void test1(){

  System.out.println("返回值类型为空，没有参数的方法");

}

public  int test2(){

  System.out.println("返回值类型为int，没有参数的方法");

  return  0;

}

public  void test3(int  num){

  System.out.println("返回值类型为空，有一个int型参数的方法");

}

public  double test4(int  num1,double num2){

  System.out.println("返回值类型为double，有两个参数的方法");

  return  0;

}

}

      2.java类中方法的分类

          方法格式1： 实例方法----没有static修饰的普通方法

           访问修饰符  返回值类型   方法名称(参数){

                  实现某一项功能的java代码

              }  

          方法格式2： 静态方法【类方法】---有static修饰的普通方法

           访问修饰符 static 返回值类型   方法名称(参数){

                         实现某一项功能的java代码

                }  

        方法格式3： 构造方法---1.没有返回值类型部分

                                                2.方法名称和所造类的类名一样

           访问修饰符    类名(参数){

                        实现某一项功能的java代码

              }  

package com.click369.test.demo3;

public class TestClass { 

 public  TestClass(){

   System.out.println("没有参数的构造方法");  

 }

  public  void  test1(){

  System.out.println("没有返回值，没有参数的实例方法");

  }

  public  static  double testStatic(double num){

  System.out.println("有返回值，有参数的静态方法");

  return num;

  }

}

3.出现在一个java类中的方法的差别

           实例方法：1.没有static修饰

                             2.其他类中被使用的时候通过对象调用

           静态方法【类方法】：1.有static修饰

                                               2.其他类中被使用的时候可以用对象访问，也可以用类名访问

            构造方法：1.没有返回值部分，方法名称和类名一样

                               2.new  构造方法；【创建对象】

                    注意：1.一个类被创建出来以后，本身就有一个无参数的构造方法存在，只是我们通常不会显式写出这个构造方法。

                               2.当一个类中出现了一个有参数的构造方法时，往往需要将这个无参数的构造方法显式写出

package com.click369.test.demo3;

public class TestClass {

 //当一个类中出现了一个有参数的构造方法时，往往需要将这个无参数的构造方法显式写出

 public TestClass(){

 System.out.println("无参数的构造方法");

 }

public  TestClass(int  num){

 System.out.println("有参数的构造方法");

}

//实例方法

  public  void  test1(){

  System.out.println("没有返回值，没有参数的实例方法");

  }

//类方法

  public  static  double testStatic(double num){

  System.out.println("有返回值，有参数的静态方法");

  return num;

  }

}

测试代码：

public static void main(String[] args) {

//实例方法---其他类中被使用的时候通过对象调用

  // TestClass tc1= new  TestClass();

  //tc1.test1();

//静态方法【类方法】---其他类中被使用的时候可以用对象访问，也可以用类名访问

//对象访问

//TestClass tc1= new  TestClass();

//tc1.testStatic(12.5);

//类名访问

//TestClass.testStatic(168.5);

//构造方法-----new  构造方法；【创建对象】

new TestClass();

new TestClass(100);

}