其他分享
首页 > 其他分享> > 对象与类

对象与类

作者:互联网

概念

对象:对象是类的一个实例(对象不是找个女朋友),有状态和行为。

例如,一条狗是一个对象,它的状态有:颜色、名字、品种;行为有:摇尾巴、叫、吃等。

类:类是一个模板,它描述一类对象的行为和状态。

例如:狗就是一类,而指定的一条狗就是对象;

就拿狗举例;

狗这个物种就是一类,包含了颜色,名字,品种等属性(状态);也包含了吃,喝,玩,睡等行为(方法);

public class Dog {
    //属性
    String breed;
    int size;
    String colour;
    int age;

    //方法
    void eat() {
    }
 
    void run() {
    }
 
    void sleep(){
    }
 
    void name(){
    }
}

构造方法

构造方法是一个比较特殊的方法,通过构造方法可以完成对象的创建,以及实例变量的初始化。

换句话说:构造方法是用来创建对象,并且同时给对象的属性赋值。

注意:实例变量没有手动赋值的时候,系统会赋默认值。

构造方法的定义与语法如下

[修饰符列表] 构造方法名(形式参数列表)
{
	构造方法体;
	通常在构造方法体当中给属性赋值,完成属性的初始化。
}

普通方法的定义与语法如下

	[修饰符列表] 返回值类型 方法名(形式参数列表)
        {
		方法体;
	}

对于构造方法来说

第一:修饰符列表目前统一写:public。千万不要写public static。

第二:构造方法名和类名必须一致。

第三:构造方法不需要指定返回值类型,也不能写void,写上void表示普通方法,就不是构造方法了。

创建对象

在Java中,使用关键字 new 来创建一个新的对象。

创建一个新的对象一般需要三步

声明:声明一个对象,包括对象名称和对象类型。

实例化:使用关键字 new 来创建一个对象。

初始化:使用 new 创建对象时,会调用构造方法初始化对象。

public class Puppy//这个puppy只是一个项目名
{
   public Puppy(String name)//创建一个puppy构造方法(C++里叫函数),需要一个String参数
   {
      //这个构造器仅有一个参数:name
      System.out.println("小狗的名字是 : " + name ); 
   }
   public static void main(String[] args)
   {
      // 下面的语句将创建一个Puppy对象
      Puppy myPuppy = new Puppy( "tommy" );//进入puppy函数
   }
}

最终打印出来的是

小狗的名字是 : tommy

访问实例变量和方法

/* 实例化对象 */

Object referenceVariable = new Constructor();

命名的函数类型 + 名字 = new + 需要对其处理的函数名及其括号内适当的格式;

/* 访问类中的变量 */

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 ); 
   }
}

源文件声明

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

一个源文件中只能有一个 public 类
一个源文件可以有多个非 public 类
源文件的名称应该和 public 类的类名保持一致。例如:源文件中 public 类的类名是 Employee,那么源文件应该命名为Employee.java。

如果一个类定义在某个包中,那么 package 语句应该在源文件的首行。

如果源文件包含 import 语句,那么应该放在 package 语句和类定义之间。如果没有 package 语句,那么 import 语句应该在源文件中最前面。

import 语句和 package 语句对源文件中定义的所有类都有效。在同一源文件中,不能给不同的类不同的包声明。

类有若干种访问级别,并且类也分不同的类型:抽象类和 final 类等。

除了上面提到的几种类型,Java 还有一些特殊的类,如:内部类、匿名类。

import与package

import 语句就是用来提供一个合理的路径,使得编译器可以找到某个类。

例如,下面的命令行将会命令编译器载入 java_installation/java/io 路径下的所有类

import java.io.*;

package 的作用就是 c++ 的 namespace 的作用,防止名字相同的类产生冲突。

Java 编译器在编译时,直接根据 package 指定的信息直接将生成的 class 文件生成到对应目录下。

如 package aaa.bbb.ccc 编译器就将该 .java 文件下的各个类生成到 ./aaa/bbb/ccc/ 这个目录。

import 是为了简化使用 package 之后的实例化的代码。
假设 ./aaa/bbb/ccc/ 下的 A 类,假如没有 import,实例化A类为:new aaa.bbb.ccc.A(),使用 import aaa.bbb.ccc.A 后,就可以直接使用 new A() 了,也就是编译器匹配并扩展了 aaa.bbb.ccc. 这串字符串。

举例

在该例子中,我们创建两个类:Employee 和 EmployeeTest。

Employee 类有四个成员变量:name、age、designation 和 salary。该类显式声明了一个构造方法,该方法只有一个参数。

//Employee
import java.io.*;
 
public class Employee{
   String name;
   int age;
   String designation;
   double salary;
   // Employee 类的构造器
   public Employee(String name){
      this.name = name;
   }
   // 设置age的值
   public void empAge(int empAge){
      age =  empAge;
   }
   /* 设置designation的值*/
   public void empDesignation(String empDesig){
      designation = empDesig;
   }
   /* 设置salary的值*/
   public void empSalary(double empSalary){
      salary = empSalary;
   }
   /* 打印信息 */
   public void printEmployee(){
      System.out.println("名字:"+ name );
      System.out.println("年龄:" + age );
      System.out.println("职位:" + designation );
      System.out.println("薪水:" + salary);
   }
}

由于程序都是从main方法开始执行。为了能运行这个程序,必须包含main方法并且创建一个实例对象。

所以选择创建一个EmployeeTest.java

import java.io.*;
public class EmployeeTest{
 
   public static void main(String[] args){
      /* 使用构造器创建两个对象 */
      Employee empOne = new Employee("RUNOOB1");
      Employee empTwo = new Employee("RUNOOB2");
 
      // 调用这两个对象的成员方法
      empOne.empAge(26);
      empOne.empDesignation("高级程序员");
      empOne.empSalary(1000);
      empOne.printEmployee();
 
      empTwo.empAge(21);
      empTwo.empDesignation("菜鸟程序员");
      empTwo.empSalary(500);
      empTwo.printEmployee();
   }
}

得到结果

$ javac EmployeeTest.java
$ java EmployeeTest 
名字:RUNOOB1
年龄:26
职位:高级程序员
薪水:1000.0
名字:RUNOOB2
年龄:21
职位:菜鸟程序员
薪水:500.0

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

java 程序是从一个 public 类的 main 函数开始执行的,(其实是main线程),就像 C 程序 是从 main() 函数开始执行一样。

只能有一个 public 类是为了给类装载器提供方便。 一个 public 类只能定义在以它的类名为文件名的文件中。

每个编译单元(文件)都只有一个 public 类。

因为每个编译单元都只能有一个公共接口,用 public 类来表现。

该接口可以按照要求包含众多的支持包访问权限的类。

如果有一个以上的 public 类,编译器就会报错。

并且 public类的名称必须与文件名相同(严格区分大小写)。

当然一个编译单元内也可以没有 public 类。

成员变量和类变量的区别

由static修饰的变量称为静态变量,其实质上就是一个全局变量。

如果某个内容是被所有对象所共享,那么该内容就应该用静态修饰;没有被静态修饰的内容,其实是属于对象的特殊描述。

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

成员变量和类变量的区别:

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

  成员变量随着对象的创建而存在,随着对象的回收而释放。

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

2、调用方式不同

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

  静态变量可以被对象调用,还可以被类名调用。

3、别名不同

  成员变量也称为实例变量。

  静态变量也称为类变量。

4、数据存储位置不同

  成员变量存储在堆内存的对象中,所以也叫对象的特有数据。

  静态变量数据存储在方法区(共享数据区)的静态区,所以也叫对象的共享数据。

static

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

特点:

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

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

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

弊端:

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

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

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

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

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

什么时候定义静态成员呢?或者说:定义成员时,到底需不需要被静态修饰呢?

成员分两种:

1、成员变量。(数据共享时静态化)

  该成员变量的数据是否是所有对象都一样:

  如果是,那么该变量需要被静态修饰,因为是共享的数据。 

  如果不是,那么就说这是对象的特有数据,要存储到对象中。 

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

  如果判断成员函数是否需要被静态修饰呢?

  只要参考,该函数内是否访问了对象中的特有数据:

  如果有访问特有数据,那方法不能被静态修饰。

  如果没有访问过特有数据,那么这个方法需要被静态修饰。

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

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

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

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

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

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

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

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

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

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

类变量类型:

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

public class  ClassName{
    public void printNumber(){
        int a;
    }
    // 其他代码
}

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

public class  ClassName{
    int a;
    public void printNumber(){
        // 其他代码
    }
}

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

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

类的构造方法

1、构造方法的名字和类名相同,并且没有返回值。

2、构造方法主要用于为类的对象定义初始化状态。

3、我们不能直接调用构造方法,必须通过new关键字来自动调用,从而创建类的实例。

4、Java的类都要求有构造方法,如果没有定义构造方法,Java编译器会为我们提供一个缺省的构造方法,也就是不带参数的构造方法。

new关键字的作用

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

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

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

标签:变量,构造方法,对象,成员,静态,public
来源: https://www.cnblogs.com/RimekeyBergling/p/16676168.html