java03.类与对象

目录

目录

       1，面向对象概述

         1.object  对象：

         2.java的三大核心特征：

2，类的定义和属性

（1）类的概念和特征：

（2）类的定义 以及 成员变量的创建和定义：

          1，类的实现：

          2，声明成员变量：

         3，方法的声明和调用

3，构造方法

（1）构造方法的定义与作用：

（2）构造方法的重载

（3）构造方法的调用

4，对象的创建与访问

（1）对象的创建：

    1.1对象的声明

    1.2 为声明的对象分配内存（即创造对象）

（2）对象的调用：

       调用对象的属性和方法

    2.1对象操作自己的成员变量：

    2.2对象调用类中的成员方法：

（3）对象的引用

        5，this关键字

---

1，面向对象概述

• 1.object  对象：

对象是系统中用来描述客观事物的一个实体

具有自己的静态结构（属性）和动态行为（方法）

• 2.java的三大核心特征：

继承性：

是指子类拥有父类的全部特征和行为。

（类间的一种关系 并且 Java 只支持单继承）

多态性：

“一个接口，多个方法”

多态性体现在父类中定义的属性和方法被子类继承后，可以具有不同的属性或表现方式。

（多态性允许一个接口被多个同类使用，弥补了单继承的不足）

封装性：

封装是将代码及其处理的数据绑定在一起的一种编程机制，该机制保证了程序和数据都不受外部干扰且不被误用。

封装的目的在于保护信息.

---

---

2，类的定义和属性

（1）类的概念和特征：

class类：是构造对象的模版和蓝图。

类是 具有共同属性和行为的对象 的 基本原型

类是对这组对象  的概括、归纳与抽象表达，

它定义了本类对象所应拥有的状态属性集（变量）及操作这组属性的行为集（方法）。

（2）类的定义 以及 成员变量的创建和定义：

属性 =成员变量=field=域or字段

方法=成员方法=函数=method

创建类对象=类的实列化=实例化类

1，类的实现：

 （1）声明类：

关键字 class

（2）类体：

    public  class {
     类体的内容
    }
[public][abstract|final]class<class_name>[extends<class_name>][implements<interface_name>] {
     //定义属性部分
    <property_type><property1>;
    <property_type><property2>;
    
    …
     //定义方法部分
    function1();
    function2();
   
    …
}

上述语法中各关键字的描述如下。

• 1.public：表示“共有”的意思。
• 如果使用 public 修饰，则可以被其他类和程序访问。每个 Java 程序的主类都必须是 public 类，作为公共工具供其他类和程序使用的类应定义为 public 类。
• 2.abstract：表示“抽象”的意思。
• 如果类被 abstract 修饰，则该类为抽象类，抽象类不能被实例化，但抽象类中可以有抽象方法（使用 abstract 修饰的方法）和具体方法（没有使用 abstract 修饰的方法）。继承该抽象类的所有子类都必须实现该抽象类中的所有抽象方法（除非子类也是抽象类）。
• 3.final：表示“最终”的意思。1/
• 如果类被 final 修饰，则不允许被继承。
• 4.class：声明类的关键字。
• class_name：类的名称。
• 5.extends：表示继承其他类。
• 6.implements：表示实现某些接口。
• property_type：表示成员变量的类型。
• property：表示成员变量名称。
• function()：表示成员方法名称。

 

（3）创造一个类的步骤：

step1:声明类

step2:声明成员变量（编写类的属性）

step3:声明成员方法（编写类的方法）

创建一个新的类，就是创建一个新的数据类型。实例化一个类，就是得到类的一个对象。

因此，对象就是一组变量和相关方法的集合，其中变量表明对象的状态和属性，方法表明对象所具有的行为。

定义类
 

范例 （创造一个person类的对象）
public class Person {

    //成员变量（实例变量），在堆中的每一个对象中储存，通过对象调用
    private String name;    // 姓名，默认值为null
    private int age;    // 年龄，默认值为0

    //成员方法（实例方法），在jvm的方法区中储存，通过对象调用
    public void tell() {   
        // 定义说话的方法
        System.out.println(name+"今年"+age+"岁！");
    }

}

2，声明成员变量：

类的成员变量：类体中变量定义部分所定义的变量。

注意：

1.成员变量在整个类中都有效

2.成员变量在定义时具有默认值

（可以在声明成员变量的同时对其进行初始化，如果声明成员变量时没有对其初始化，则系统会使用默认值初始化成员变量。初始化的默认值如下：

• 整数型（byte、short、int 和 long）的基本类型变量的默认值为 0。
• 单精度浮点型（float）的基本类型变量的默认值为 0.0f。
• 双精度浮点型（double）的基本类型变量的默认值为 0.0d。
• 字符型（char）的基本类型变量的默认值为 “\u0000”。
• 布尔型的基本类型变量的默认值为 false。
• 数组引用类型的变量的默认值为 null。如果创建了数组变量的实例，但没有显式地为每个元素赋值，则数组中的元素初始化值采用数组数据类型对应的默认值。）

 3.关于引用数据类型的特殊值 null:

null  在Java中表示“空引用”，即只有名字，没有任何对内存中的地址，如果直接使用值为null的引用，去操作（使用.操作符）任何属性或者方法（成员变量、成员方法），都会报错。

  如：空指针异常

        //sex的默认值为null

        //sex.length()

        System.out.println(per2.sex.length());

4.在方法体中定义的变量和方法的参数被称为局部变量。局部变量只在定义它的方法内有效，并且局部变量在定义时没有默认值。（注意：局部变量必须赋予初始值）

[public|protected|private][static][final]<type><variable_name>

（1）声明成员变量时各参数的含义如下：

[public|protected|private][static][final]<type><variable_name>

• public、protected、private：用于表示成员变量的访问权限。
• static：表示该成员变量为类变量，也称为静态变量。
• final：表示将该成员变量声明为常量，其值无法更改。
• type：表示变量的类型。
• variable_name：表示变量名称。

（2）举例：

public class Counter {
    static int sum;
    public static void main(String[] args) {
        System.out.println(sum);
    }
}

//先定义一个Student类，在类中通过属性定义学生、性别和年龄，代码如下：
public class Student {
    public String Name;    // 学生姓名
    public int Age;    // 学生年龄
    private boolean Sex;    // 学生性别
}
//在上述代码中将学生性别属性 Sex 设置为 private 作用域。为了对该属性进行获取和设置，还需要编写 isSex 和 setSex 方法。代码如下：
//获取
public boolean isSex() {
    return Sex;
}
//设置
public void setSex(boolean sex) {
    this.Sex = sex;
}//在 Student 类中添加 main() 方法，然后创建两个学生类的实例，并输出学生信息
public static void main(String[] args) {
    Student zhang = new Student(); // 创建第一个实例
    zhang.Name = "张子同";
    String isMan = zhang.isSex() ? "女" : "男";
    System.out.println("姓名：" + zhang.Name + "性别：" + isMan + "年龄：" + zhang.Age);
    Student li = new Student(); // 创建第二个实例
    li.Name = "李子文";
    li.Sex = true;
    li.Age = 15;
    String isWoman = li.isSex() ? "女" : "男";
    System.out.println("姓名：" + li.Name + "性别：" + isWoman + "年龄：" + li.Age);
}

输出结构：
姓名：张子同性别：男年龄：0 姓名：李子文性别：女年龄：15

3，方法的声明和调用

一个完整的方法通常包括方法名称、方法主体、方法参数和方法返回值类型

public class Test //方法头{
 [public|private|protected][static]<void|return_type><method_name>([paramList]){
        // 方法体的内容
    }
}

成员方法与构造方法的区别与联系：类方法（成员方法）与构造方法的区别与联系_33三 三like的博客-CSDN博客

（1）方法体修饰符的含义如下:

[public | private | protected ][static]<void|return_type><method_name>([paramList])
 

• public、private、protected：表示成员方法的访问权限。
• static：表示限定该成员方法为静态方法。
• final：表示限定该成员方法不能被重写或重载。
• abstract：表示限定该成员方法为抽象方法。抽象方法不提供具体的实现，并且所属类型必须为抽象类

（2）成员方法的返回值：

return 表达式    或者return (表达式)

其中，表达式可以是常量、变量、对象等。表达式的数据类型必须与声明成员方法时给出的返回值类型一致。

（3）形参、实参及成员方法的调用：

methodName({paramList})

形参是定义方法时参数列表中出现的参数，实参是调用方法时为方法传递的参数。

<1>形参：用来接收调用方法时传递的参数，只有在被调用时才分配内存，一旦调用结束，就释放内存空间。因此仅在方法内有效。

<2>实参：实际传递的参数

方法相关注意事项：类方法（成员方法）与构造方法的区别与联系_33三 三like的博客-CSDN博客

---

---

3，构造方法

（1）构造方法的定义与作用：

构造方法（也称为构造器）是一个特殊的成员方法（类方法），其名字必须与类名相同，

在创建对象时由编译器自动调用，并且在整个对象的生命周期内只调用一次。

构造方法的作用就是对对象中的成员进行初始化，并不负责给对象开辟空间。

• 构造方法的名字必须与它所在的类的名字完全相同，并且没有返回类型。
• 构造方法在创建对象时被系统调用。
• 构造方法的作用是为对象分配内存空间，为对象的属性赋予初始值。

（如果类中无构造方法，那么系统回默认该类只有一个构造方法，并且该构造方法无参数，方法体中无语句）

(注：不能否用一个实例化对象去调用它的构造方法。 构造方法的作用是产生对象，如果用构造方法产生的对象去调用产生它的构造方法，就相当于自己又在自己的构造方法（我生我自己）。）

（2）构造方法的重载

允许一个类中编写若干个方法名相同的构造方法，但必须保证它们的参数不同（即参数的个数不同，或者个数相同时参数的类型不同）

（如果一个类里定义了一个或者多个构造方法，那么java不提供默认的构造方法。）

public class main {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		        //创建一个对象
		        Data data = new Data(2022,11,13);
		        data.printDate();
	}
}
 class Data {//数据类
    //成员变量：
    public int year;
    public int month;
    public int day;
    //构造方法：
    public Data(int year, int month, int day) {
        //构造方法名字与类名字相同
        //构造方法没有返回类型
        this.year = year;
        this.month = month;
        this.day = day;
        System.out.println("调用构造方法");
    }
    //成员方法（类方法）
    public void printDate() {
        System.out.println("类方法:"+year + "-" + month + "-" + day);
    }
}
//输出：调用构造方法
//输出：类方法:2022-11-13

public class Person{
     private int age;
     private String name;
     //下面是三种构造方法：
     //无参构造方法
      public Person(){
         System.out.println("无参构造方法");
        }
      //一个参数的构造方法
      public Person(int age){
            this.age = age;
      }
      //两个参数的构造方法
      public Person(int age,String name){
            this.age=  age;
           this.name = name;
      }
}

（3）构造方法的调用

在类中创建对象时，系统会根据参数的个数和类型，调用对应的构造方法

---

---

4，对象的创建与访问

类名字 对象名字 = new 类名字（ ）；

Person per = new  Person( );

  这个对象的引用   对象（在堆中储存）

（相当于给对象起了个名字）（所有类的对象都是引用数据类型）

public classStudentDemo {
    public static void main(String[] args) {
        //格式：类名对象名 = new 类名();
        Student s = new Student();
        //直接输出成员变量值
        System.out.println("姓名："+s.name); //null
        System.out.println("年龄："+s.age); //0
       System.out.println("----------");
        //给成员变量赋值
        s.name = "林青霞";
        s.age = 28;
        //再次输出成员变量的值：
        System.out.println("姓名："+s.name); //林青霞
        System.out.println("年龄："+s.age); //28
       System.out.println("----------");
        //调用成员方法
        s.study();
        s.eat();
    }
}

（1）对象的创建

【创造一个对象包括：对象的声明 + 为对象分配内存】

class Rect { //我们先在这里定义一个Rect类，便于后面使用
           int width;
           int height;
           Rect(){
           height=0;
           width=0;
            }
           Rect(int w,int h) { 
           height=h;
           width=w;
            }
           void setWidth(int w) {
            width=w;
           }
           int getArea(){
           int area=width*height;
          return area;
          }
}

1.1对象的声明

一般格式：    类名字  对象名字；

Eg： Rect   r;

声明对象的时候对象的内存空间是null

1.2 为声明的对象分配内存（即创造对象）

【1】使用new运算符和类构造方法为声明的对象分配变量，即创造对象。

类名 对象名=new 类名（）；

Eg：Rect  r=new Rect（）；

【1】创造对象后的内存空间模型为：

【2】创造多个不同对象

Rect r1=new Rect ();

Rect r2= new Rect(4,7);

（2）对象的调用：

调用对象的属性和方法

运用       .    运算符

访问成员变量：

对象名.属性名;

访问成员方法：

对象名.方法名（实参数）；

2.1对象操作自己的成员变量：

格式： 对象名.成员变量名

 int x=r1.width;
       r1.width=x+10;

2.2对象调用类中的成员方法：

格式：对象名.方法名

 r1.setWidth（10）；
int s1=r1.getArea();
int s2=r2.getArea();

（3）对象的引用

(对象的名宇，可以认为是该对象对应内存区域的一个引用，即：一个别名)

class Point {
//定义一个Point类
   double x,y;//在Point中创建了两个变量x，y；
    Point(double x,double y)
         {   this.x=x;   this.y=y;
           }
}
public class Point{//使用Point 类创造了两个对象p1,p2;
    Point p1 =new Point (5,15);
    Point P2 =new Point (8,18);
}

注：如果中程序中使用了赋值语句：p1=p2；

即把p2中的引用赋给了p1，因此p1，p2本质上是一样的，p2改变p1也发生同样的改变，p1改变p2也发生同样改变，它们具有完全相同的实体（变量）。

内存模型为：

---

---

5，this关键字

1.this可以出现在实例方法和构造方法中（不能出现在类方法中），this关键字用来访问本类的属性，成员方法，构造方法。

2.this是成员方法的一个特殊的固有的本地变量，它表达了调用这个函数的这个对象,每个对象都有自己特定的this（这些this互不相同）

3.this可以使用在构造方法或者实例方法中（用于区分局部变量和实例变量，此时this不能被省略），但是this不能使用在静态方法中（即this只能在类定义的方法中使用，不能在类定义的外部使用）。

4.访问成员方法的语法：this.方法名（参数列表）；

访问构造方法的语法：this（参数列表）；注意：只能在构造方法中使用。