菜鸟学java对象和类

左手的ㄟ右手 2023-10-12 21:24 6阅读 0赞

#### 对象和类 ####

*   *  1、类型变量
     *  2、创建对象
     *  3、访问实例变量和方法
     *   *  实例
     *  4、源文件声明规则
     *  5、成员变量和类变量的区别
     *  6、new关键字的作用
     *  7、内部类优点和缺点

### 1、类型变量 ###

*  局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
 *  成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
 *  类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型。  
    一个类可以拥有多个方法，在上面的例子中：eat()、run()、sleep() 和 name() 都是 Dog 类的方法。

### 2、创建对象 ###

对象是根据类创建的。在Java中，使用关键字 new 来创建一个新的对象。创建对象需要以下三步：

*  声明：声明一个对象，包括对象名称和对象类型。
 *  实例化：使用关键字 new 来创建一个对象。
 *  初始化：使用 new 创建对象时，会调用构造方法初始化对象。

下面是一个创建对象的例子：

public class Puppy{
        
       public Puppy(String name){
        
          //这个构造器仅有一个参数：name
          System.out.println("小狗的名字是 : " + name ); 
       }
       public static void main(String[] args){
        
          // 下面的语句将创建一个Puppy对象
          Puppy myPuppy = new Puppy( "tommy" );
       }
    }

输出

小狗的名字是 : tommy

### 3、访问实例变量和方法 ###

通过已创建的对象来访问成员变量和成员方法，如下所示：

/* 实例化对象 */
    Object referenceVariable = new Constructor();
    /* 访问类中的变量 */
    referenceVariable.variableName;
    /* 访问类中的方法 */
    referenceVariable.methodName();

#### 实例 ####

下面的例子展示如何访问实例变量和调用成员方法：

public class Puppy{
        
       int puppyAge;
       public Puppy(String name){
        
          // 这个构造器仅有一个参数：name
          System.out.println("小狗的名字是 : " + name ); 
       }
     
       public void setAge( int age ){
        
           puppyAge = age;
       }
     
       public int getAge( ){
        
           System.out.println("小狗的年龄为 : " + puppyAge ); 
           return puppyAge;
       }
     
       public static void main(String[] args){
        
          /* 创建对象 */
          Puppy myPuppy = new Puppy( "tommy" );
          /* 通过方法来设定age */
          myPuppy.setAge( 2 );
          /* 调用另一个方法获取age */
          myPuppy.getAge( );
          /*你也可以像下面这样访问成员变量 */
          System.out.println("变量值 : " + myPuppy.puppyAge ); 
       }
    }

输出

小狗的名字是 : tommy
    小狗的年龄为 : 2
    变量值 : 2

### 4、源文件声明规则 ###

当在一个源文件中定义多个类，并且还有import语句和package语句时，要特别注意这些规则。

*  一个源文件中只能有一个 public 类
 *  一个源文件可以有多个非 public 类
 *  源文件的名称应该和 public 类的类名保持一致。例如：源文件中 public 类的类名是 Employee，那么源文件应该命名为Employee.java。
 *  如果一个类定义在某个包中，那么 package 语句应该在源文件的首行。
 *  如果源文件包含 import 语句，那么应该放在 package 语句和类定义之间。如果没有 package 语句，那么 import 语句应该在源文件中最前面。
 *  import 语句和 package 语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。
 *  类有若干种访问级别，并且类也分不同的类型：抽象类和 final 类等。
 *  除了上面提到的几种类型，Java 还有一些特殊的类，如：内部类、匿名类。

> 为什么JAVA文件中只能含有一个Public类?

java 程序是从一个 public 类的 main 函数开始执行的，(其实是main线程)，就像 C 程序 是从 main() 函数开始执行一样。 只能有一个 public 类是为了给类装载器提供方便。 一个 public 类只能定义在以它的类名为文件名的文件中。

每个编译单元(文件)都只有一个 public 类。因为每个编译单元都只能有一个公共接口，用 public 类来表现。该接口可以按照要求包含众多的支持包访问权限的类。如果有一个以上的 public 类，编译器就会报错。 并且 public类的名称必须与文件名相同(严格区分大小写)。 当然一个编译单元内也可以没有 public 类。

成员变量和类变量的区别

由static修饰的变量称为静态变量，其实质上就是一个全局变量。如果某个内容是被所有对象所共享，那么该内容就应该用静态修饰；没有被静态修饰的内容，其实是属于对象的特殊描述。

不同的对象的实例变量将被分配不同的内存空间， 如果类中的成员变量有类变量，那么所有对象的这个类变量都分配给相同的一处内存，改变其中一个对象的这个类变量会影响其他对象的这个类变量，也就是说对象共享类变量。

### 5、成员变量和类变量的区别 ###

*  类变量：定义在类中，方法体之外，但必须要有 static 来声明变量类型。静态成员属于整个类，可通过对象名或类名来调用。

public class  ClassName{
        
        static int a;
        public void printNumber（）{
        
            // 其他代码
        }
    }

*  成员变量：定义在类中，方法体之外。变量在创建对象时实例化。成员变量可被类中的方法、构造方法以及特定类的语句块访问。

public class  ClassName{
        
        int a;
        public void printNumber（）{
        
            // 其他代码
        }
    }

*  局部变量：在方法、构造方法、语句块中定义的变量。其声明和初始化在方法中实现，在方法结束后自动销毁

public class  ClassName{
        
        public void printNumber（）{
        
            int a;
        }
        // 其他代码
    }

详细来说：

1、两个变量的生命周期不同

成员变量随着对象的创建而存在，随着对象的回收而释放。
    
      静态变量随着类的加载而存在，随着类的消失而消失。

2、调用方式不同

成员变量只能被对象调用。
    
      静态变量可以被对象调用，还可以被类名调用。

3、别名不同

成员变量也称为实例变量。
    
      静态变量也称为类变量。

4、数据存储位置不同

成员变量存储在堆内存的对象中，所以也叫对象的特有数据。
    
      静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。

static 关键字，是一个修饰符，用于修饰成员(成员变量和成员函数)。

特点：

1、想要实现对象中的共性数据的对象共享。可以将这个数据进行静态修饰。

2、被静态修饰的成员，可以直接被类名所调用。也就是说，静态的成员多了一种调用方式。类名.静态方式。

3、静态随着类的加载而加载。而且优先于对象存在。

弊端：

1、有些数据是对象特有的数据，是不可以被静态修饰的。因为那样的话，特有数据会变成对象的共享数据。这样对事物的描述就出了问题。所以，在定义静态时，必须要明确，这个数据是否是被对象所共享的。

2、静态方法只能访问静态成员，不可以访问非静态成员。

因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。

3、静态方法中不能使用this，super关键字。

因为this代表对象，而静态在时，有可能没有对象，所以this无法使用。

> 什么时候定义静态成员呢？或者说：定义成员时，到底需不需要被静态修饰呢？

成员分两种：

1、成员变量。（数据共享时静态化）

该成员变量的数据是否是所有对象都一样：
    
      如果是，那么该变量需要被静态修饰，因为是共享的数据。 
    
      如果不是，那么就说这是对象的特有数据，要存储到对象中。

2、成员函数。（方法中没有调用特有数据时就定义成静态）

如果判断成员函数是否需要被静态修饰呢？
    
      只要参考，该函数内是否访问了对象中的特有数据：
    
      如果有访问特有数据，那方法不能被静态修饰。
    
      如果没有访问过特有数据，那么这个方法需要被静态修饰。

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

1、成员变量所属于对象。所以也称为实例变量。

静态变量所属于类。所以也称为类变量。

2、成员变量存在于堆内存中。

静态变量存在于方法区中。

3、成员变量随着对象创建而存在。随着对象被回收而消失。

静态变量随着类的加载而存在。随着类的消失而消失。

4、成员变量只能被对象所调用 。

静态变量可以被对象调用，也可以被类名调用。

所以，成员变量可以称为对象的特有数据，静态变量称为对象的共享数据。

### 6、new关键字的作用 ###

1、为对象分配内存空间。

2、引起对象构造方法的调用。

3、为对象返回一个引用。

> 使用java类实例化一个对象的时候，如果在类中不显式的声明其构造函数，则会使用一个默认的构造函数来初始化对象。

实例：

//一个没有显式声明构造函数的类
    Public class People{
        
        int age = 23;
        Public void getAge(){
        
            System.out.print("the age is "+age);
        }
    }
    
    //用这个类来实例化一个对象
    People xiaoMing = new People(); // People() 是People类的默认构造函数，它什么也不干
    xiaoMing.getAge();//打印年龄

也可以在声明类的时候显式的声明一个构造函数：

//一个带显式构造函数的类
    Public class People{
        
        int age = 23;
            Public void getAge(){
        
            System.out.print("the age is "+ age);
        }
        // 显式声明一个带参数的构造函数，用于初始化年龄
        Public People(int a){
        
            this.age = a; 
        }
    }
    
    //用这个类来实例化一个对象
    People xiaoMing = new People(20); // 使用带参数的构造函数来实例化对象
    xiaoMing.getAge(); // 打印出来的年龄变为20

*  this 指向对象本身的指针，形参与成员名字重名，用 this 来区分。  
    [this的优秀教程][this]: https://blog.csdn.net/benxiangsj/article/details/124282800
 *  super 超（父）类对象的一个指针。  
    [ super的优秀教程][super]：https://blog.csdn.net/qq\_46096136/article/details/126171232

### 7、内部类优点和缺点 ###

*  优点：可访问外部类私有属性（心脏可访问身体的血液，而不是外部抽血）。
 *  缺点：破坏原有类的程序结构（属性、构造方法、普通方法、内部类）。

//外部类
    class Out {
        
        private int age = 12;
         
        //内部类
        class In {
        
            public void print() {
        
                System.out.println(age);
            }
        }
    }
     
    public class Demo {
        
        public static void main(String[] args) {
        
            Out.In in = new Out().new In();
            in.print();
            //或者采用下种方式访问
            /*
            Out out = new Out();
            Out.In in = out.new In();
            in.print();
            */
        }
    }

运行结果：12

> 从上面的例子不难看出，内部类其实严重破坏了良好的代码结构，但为什么还要使用内部类呢？

因为内部类可以随意使用外部类的成员变量（包括私有）而不用生成外部类的对象，这也是内部类的唯一优点。

如同心脏可以直接访问身体的血液，而不是通过医生来抽血。

程序编译过后会产生两个 .class 文件，分别是 Out.class 和 Out$In.class。

其中 $ 代表了上面程序中 Out.In 中的那个。

Out.In in = new Out().new In()

可以用来生成内部类的对象，这种方法存在两个小知识点需要注意：

1.  开头的 Out 是为了标明需要生成的内部类对象在哪个外部类当中。
2.  必须先有外部类的对象才能生成内部类的对象，因为内部类的作用就是为了访问外部类中的成员变量。

[this]: https://blog.csdn.net/benxiangsj/article/details/124282800
[super]: https://blog.csdn.net/qq_46096136/article/details/126171232