ICode9

精准搜索请尝试: 精确搜索
首页 > 其他分享> 文章详细

对象与类

2022-09-10 11:01:26  阅读:288  来源: 互联网

标签:变量 构造方法 对象 成员 静态 public


概念

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

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

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

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

就拿狗举例;

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

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

本站声明: 1. iCode9 技术分享网(下文简称本站)提供的所有内容,仅供技术学习、探讨和分享;
2. 关于本站的所有留言、评论、转载及引用,纯属内容发起人的个人观点,与本站观点和立场无关;
3. 关于本站的所有言论和文字,纯属内容发起人的个人观点,与本站观点和立场无关;
4. 本站文章均是网友提供,不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属;如您发现该文章侵犯了您的权益,可联系我们第一时间进行删除;
5. 本站为非盈利性的个人网站,所有内容不会用来进行牟利,也不会利用任何形式的广告来间接获益,纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

专注分享技术,共同学习,共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有