java的类(Class)和对象(Object)

目录

                          引言

一.类的定义及对象的创建

1.对象的创建

​编辑

3.访问对象的成员

4.访问修饰符

5.程序举例

二.getter与setter方法

1.getter与setter的定义

(1)getter方法 

(2)setter方法 

三.构造方法

1.构造方法的定义

2.构造方法的重载 

四. 静态成员 

1.静态方法的定义与调用

2.举例一个简单明了的静态成员方法的代码

---

引言

Java是一种面向对象的编程语言，因此它的基本概念是类和对象。

类(Class)是一种组织代码的方式，它是一组相关属性和方法的集合。Java中的所有代码都必须定义在类中，因此，我们可以将类看作是一种模板或蓝图，用来创建对象。

对象(Object)是类的实例化对象，它是具有一定状态和行为的实体。在Java中，我们使用关键字“new”来创建对象，并将其保存在变量中。对象可以调用类中定义的方法，修改或访问其属性。

例如，我们可以定义一个名为“Student”的类，其中包含姓名、年龄和性别等属性，还有一些方法，如“说话”、“走路”和“吃饭”。

当我们创建一个具体的“Student”对象时，我们可以给它设置具体的姓名、年龄和性别等属性，还可以调用“说话”、“走路”和“吃饭”等方法。这样，我们就可以使用对象来模拟现实中的人类行为。

一.类的定义及对象的创建

(1)类的定义

类是一种抽象数据类型，它定义了对象的属性和方法。在Java中，每个类都必须有一个类名，类名通常使用大写字母开头，并且要与源代码文件名相同。例如，类名为MyClass的类应该定义在MyClass.java文件中。

类

（2）创建一个类：在Java中，所有的代码都必须位于一个类中。可以使用关键字class来定义一个类，如下所示：

public class MyStudent {
    // 类的内容
}

（3）声明类的属性：类的属性也称为成员变量，是描述类的特征的变量。可以将其声明在类中，如下所示：

public class MyStudent {
    private String name;
    private int age;
}
 

（4）声明类的方法：类的方法也称为成员方法，是执行特定任务的代码块。可以将其声明在类中，如下所示：

public class MyStudent {
    private String name;
    private int age;

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

---

1.对象的创建

创建对象：可以使用new关键字创建类的对象，如下所示： 

MyStudent= new MyStudent();

给对象赋值：可以使用类的方法给对象赋值，如下所示：

stu1.setName("Tom");
stu1.setAge(20);

 

3.访问对象的成员

访问对象的属性和方法：可以使用.运算符访问对象的属性和方法，如下所示：

String name = stu.name;
int age = stu.age;
 

4.访问修饰符

访问修饰符使类或者类的成员在不同的范围内具有不同的可见性用于实现数据和代码的隐藏

访问修饰符表格:

访问修饰符	 同类	 同包	子类	其他包
public	       ✔️	  ✔️	  ✔️    ✔️
protected	   ✔️	  ✔️	  ✔️    ❌	     
default	       ✔️	  ✔️	  ❌    ❌
private	       ✔️	  ❌	  ❌	 ❌

其中的符号含义如下:
✔️：可以访问
❌：无法访问

eclipse我编写java代码所使用的一个软件。

---

5.程序举例

（1)根据上述定义一个学生类(Student),其中成员变量有姓名（name),年龄（age),性别（sex),成绩为score1() 、score2()。成员方法sumOfScore,用于计算两门成绩之和。学生类(Student)定义如下：

public class Student {        //定义学生类，类名Student
public String name;	              //定义String类型的变量name成员变量，名字	
public int age;	             //定义int类型的变量age年龄	
public string sex;	                //成员变量，性别	
public int score1;	              //成员变量,成绩1	
public int score2;	                //成员变量,成绩2	

//sumOfScore成员方法，计算两门成绩之和	
	
public int sumOfScore(){ 
  return score1+score2; 
}

Student类中没有main方法，不能运行，我们需要建立一个测试类

建立测试类方法如下：

(2) 建立一个学生测试类TestStudent，用与测试上面定义的学生测试类

public class TestStudent{          //这个类的目的是测试Student类
public static void main(String[] args) {
   Student stu1= new Student();   //创建学生类stu1 
   stul.name="小明";          //为stu1的name属性赋值 
   stul.age 19;              //为stu1的age属性赋值 
   stul.sex="男";           //为stu1的sex属性赋值
   stul.score1=89:         //stu1的成绩1设置为89	
   stul.score2=99;        //stu2的成绩1设置为99	
 
 	//输出姓名与年龄和性别
	
 	System.out.printin("stul名字为:"+stul.name);      //stu1.name调用对象的方法	
 	System.out.prinLln("sLu1年龄为:"+stu1.age);
    Systcm.out.println("stul性别为:"+stu1.sex);

     //计算输出两门成绩之和
   system.out.println ("stu1两门成绩之和为:"+stu1.sum0fScore());

结果如下所示：

 stu1名字为：小明
 stu1年龄为：19
 stu1性别为：男
 stu1两门成绩之和为:188

二.getter与setter方法

1.getter与setter的定义

(1)getter方法 

- 返回对象内部的成员变量的值 
格式： 
[访问修饰符]  成员变量类型 getXxx() {
     return  成员变量;
}

getter方法中没有void（无返回值)

getter方法通常以get开头，并返回相应的属性值，常用于访问类的成员变量，getter方法通常用于获取对象属性的值，而不是直接访问属性本身。使用getter方法可以控制属性的访问权限，并提供更好的封装和面向对象编程。

getter 方法通常应该是 public 访问权限，以便其他对象可以使用它来读取属性值。

以下是getter方法的使用示例：

public class Person {
    private String name;
    private int age;

    
    public String getName() {
        return name;
    }

    
    public int getAge() {
        return age;
    }

(2)setter方法 

- 用来设置成员变量，可以在方法里面过滤掉一些不合理的值 
格式： 
[访问修饰符]   void setXxx (成员变量类型 参数)  { 
      成员变量=参数；  
} 

setter方法中有void

   
    public void setName(String name) {
        this.name = name;
    }


    public void setAge(int age) {
        this.age = age;
    }
}

在上面的代码中，我们定义了两个属性 name 和 age，以及对应的 getter 和 setter 方法。getter 方法可以让其他对象读取这些属性的值，setter 方法可以让其他对象修改这些属性的值。

三.构造方法

1.构造方法的定义

[访问修饰符 ] class  类名{
public  类名([形参列表]){
     方法体；
}
其它类成员声明；
}

构造方法的访问修饰符可以是public、private、protected，与普通的成员方法一样。如果将构造方法声明为private，则该类就不能被其他类继承

下面我们来举例一个简单的构造方法：

   // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 获取姓名
    public String getName() {
        return name;
    }

    // 获取年龄
    public int getAge() {
        return age;
    }

2.构造方法的重载 

     创始对象（自动调用构造方法）

类名对象名；
对象名 = new类名 ( [ 实参列表 ] )；
或
类名对象名 = new类名(  [ 实参列表 ] )；

下面是Java中定义重载的构造方法：

public class Person {//定义一个人
    private String name;
    private int age;
    private String address;//地址

//构造方法1：接受三个参数，分别为name、age、address，用于初始化Person对象的实例变量。
    public Person(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }
//构造方法2：接受两个参数，分别为name、age，调用构造方法1来初始化实例变量，address传入null。
    public Person(String name, int age) {
        this(name, age, null);
    }
//构造方法3：接受一个参数name，调用构造方法1来初始化实例变量，age传入0，address传入null。
    public Person(String name) {
        this(name, 0, null);
    }
// 构造方法4：不接受任何参数，表示Person对象将会使用默认值进行初始化。
    public Person() {}

    // getter和setter可参考上方所写的代码，此处省略

}

Java中的构造方法可以像普通方法一样进行重载，即在同一个类中可以定义多个构造方法，只要它们的参数列表不同即可。

四. 静态成员 

类可以具有静态成员，例如静态成员变量、静态方法等。定义静态成员需要使用static修饰符。 

1.静态方法的定义与调用

关键字static表示该方法是静态方法，可以通过类名直接调用

定义一个静态方法：

// main方法是静态方法
public static void main(string[ ] args) {
…
}

public static 返回值类型 方法名(参数列表) {
    // 方法体
}

静态方法定义中需要注意的几个关键点：

• 静态方法必须使用static关键字进行修饰。
• 静态方法不能访问非静态的属性和方法，它只能访问类级别的属性和方法。
• 静态方法中不能使用this关键字，因为它没有this指向的对象。
• 静态方法可以通过类名直接调用，不需要实例化对象。

(1)静态成员的调用与实例成员的调用的区别

静态成员调用格式： 类名.成员名
如：Math、Arrays等工具类中的方法
都是静态方法
Math.sqrt(...)    
Math.pow(...)
Arrays.sort(...)

实例成员调用格式：对象名.成员名
如：之前学过的字符串操作方法是实例
方法。
String str1=“大数据技术专业”;
str1.length();
str1.toLowerCase();

2.举例一个简单明了的静态成员方法的代码

下面是一个简单明了的Java编程语言的静态成员代码，其中包含一个静态变量和一个静态方法：

public class MyClass {
    // 一个静态变量Variable 
    public static int static Variable = 0;

    // 一个静态方法Remark
    public static void static Remark() {
        System.out.println("今天的天气好美!");
    }
}

在这个例子中，静态变量static Variable被声明为public，表示它可以被该类的任何对象访问。静态方法static Remark同样也被声明为public，并且不需要通过类的实例来调用，在其他地方可以直接使用类名调用。

通过使用静态成员，我们可以在类级别上存储和访问数据，而不必依赖于具体的对象实例。这对于在多个类之间共享数据或者实现一些实用方法非常有用。