Java——类和对象

汪汪miao~

于 2023-09-13 13:28:26 发布

阅读量53

点赞数 1

分类专栏： JavaSE 文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_45559559/article/details/131054837

版权

JavaSE 专栏收录该内容

28 篇文章 0 订阅

订阅专栏

一、面向对象编程

面向对象程序三大特性：封装、继承、多态。
Java是一门纯面向对象的语言(Object Oriented Program，继承OOP)，
在面向对象的世界里，一切皆为对象。
面向对象是解决问题的一种思想，
主要依靠对象之间的交互完成一件事情。
用面向对象的思想来涉及程序，更符合人们对事物的认知，
对于大型程序的设计、扩展以及维护都非常友好。

二、类的定义和使用

面相对象程序设计关注的是对象，而对象是现实生活中的实体，
类是用来对一个实体(对象)来进行描述的，
主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能，
描述完成后计算机就可以识别了。
在这里插入图片描述
上图左侧就是对洗衣机简单的描述，
该过程称为对洗衣机对象(实体)进行抽象(对一个复杂事物的重新认知)，
但是这些简化的抽象结果计算机也不能识别，
开发人员可以采用某种面相对象的编程语言来进行描述，比如：Java语言。

1.类的定义格式

在java中定义类时需要用到class关键字，具体语法如下：

// 创建类
 class ClassName{
     field; // 字段(属性) 或者 成员变量
     method; // 行为 或者 成员方法
}

class 为定义类的关键字，
ClassName 为类的名字,
{}中为类的主体。

类中包含的内容称为 类的成员。
属性主要是用来描述类的，称之为 类的成员属性 或者 类成员变量。
方法主要说明类具有哪些功能，称为 类的成员方法。

采用Java语言将类在计算机中定义完成，经过 javac 编译之后成.class文件，在JVM的基础上计算机就可以识别了。

class WashMachine{
    public String brand;   // 品牌 
    public String type;    // 型号 
    public double weight;  // 重量 
    public double lenght;  // 长 
    public double weidth;  // 宽 
    public double height;  // 高 
    public String color;   // 颜色

    public void WashClothes(){   // 洗衣服 
        System.out.println("洗衣功能");
    }

    public void dryClothes(){    // 脱水 
        System.out.println("脱水功能"); 
    }

    public void SetTime(){       // 定时 
        System.out.println("定时功能"); 
    }

类名注意采用大驼峰定义
一般一个文件当中只定义一个类
main方法所在的类一般要使用public修饰(注意：Eclipse默认会在public修饰的类中找main方法)
public修饰的类必须要和文件名相同
不要轻易去修改public修饰的类的名称，如果要修改，通过开发工具修改。

2. 类的实例化

定义了一个类，就相当于在计算机中定义了一种新的类型，
与int，double类似，
只不过int和double是java语言自带的内置类型，
而类是用户自定义了一个新的类型。
用类类型创建对象的过程，称为类的实例化，
在java中采用new 关键字，配合类名来实例化对象。
在这里插入图片描述

public class Main{
	public static void main(String[] args) {
        PetDog dogh = new PetDog(); //通过new实例化对象
        dogh.name = "阿黄";
        dogh.color = "黑黄";
        dogh.barks();
		dogh.wag();
		PetDog dogs = new PetDog();
		dogs.name = "阿黄";
		dogs.color = "黑黄";
		dogs.barks();
		dogs.wag();
   }
}

输出结果： 
阿黄: 旺旺旺~~~ 
阿黄: 摇尾巴~~~ 
赛虎: 旺旺旺~~~ 
赛虎: 摇尾巴~~~

3. 类和对象的关系

在这里插入图片描述

类只是一个模型一样的东西，
用来对一个实体进行描述，
限定了类有哪些成员.
类是一种自定义的类型，可以用来定义变量.
一个类可以实例化出多个对象，
实例化出的对象占用实际的物理空间，
存储类成员变量。
类实例化出对象就像现实中使用建筑设计图建造出房子，
类就像是设计图，只设计出需要什么东西,
但是并没有实体的建筑存在，
同样类也只是一个设计，
实例化出的对象才能实际存储数据，占用物理空间

三、 this引用

this引用指向当前对象(成员方法运行时调用该成员方法的对象)，
在成员方法中所有成员变量的操作，都是通过该引用去访问。
this引用的是调用成员方法的对象。
只不过所有的操作对用户是透明的，
即用户不需要来传递，编译器自动完成。

public class Date { 
    public int year; 
    public int month; 
    public int day;

public void setDay(int year, int month, int day){ 
        this.year = year;
        this.month = month;
        this.day = day;
    }

public void printDate(){
        System.out.println(this.year + "/" + this.month + "/" + this.day); 
    }
}


public static void main(String[] args) { 
    Date d = new Date(); 
    d.setDay(2020,9,15); 
    d.printDate();
}

在这里插入图片描述
this引用的特性:

this的类型：
对应类类型引用，
即哪个对象调用就是哪个对象的引用类型
this只能在"成员方法"中使用
在"成员方法"中，this只能引用当前对象，
不能再引用其他对象
this是“成员方法”第一个隐藏的参数，
编译器会自动传递，
在成员方法执行时，编译器会负责将调用成员方法
对象的引用传递给该成员方法，
this负责来接收

在代码层面来简单演示—>注意：下图右侧中的Date类也是可以通过编译的
在这里插入图片描述

四、对象的构造及初始化

1. 构造方法

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

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

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

绝大多数情况下使用public来修饰，
特殊场景下会被private修饰(单例模式时会遇到)

public class Date { 
    public int year; 
    public int month; 
    public int day;


// 构造方法：
    // 名字与类名相同，没有返回值类型，设置为void也不行
    // 一般情况下使用public修饰
    // 在创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次 
    // 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)


    // 带有三个参数的构造方法
    public Date(int year, int month, int day){
        this.year = year;
        this.month = month;
        this.day = day; 
        System.out.println("Date(int,int,int)方法被调用了");
    }

  
  // 无参构造方法 
  public Date(){
    this.year = 1900; 
        this.month = 1; 
        this.day = 1;
    }



public void printDate(){
        System.out.println(year + "-" + month + "-" + day); 
}

 public static void main(String[] args) {
        // 此处创建了一个Date类型的对象，并没有显式调用构造方法 
        Date d = new Date(2021,6,9);   // 输出Date(int,int,int)方法被调用了 
        d.printDate();    // 2021-6-9
    }
    
}

  如果用户没有显式定义，编译器会生成一份默认的构造方法，
  生成的默认构造方法一定是无参的。
  一旦用户定义，编译器则不再生成。

public class Date { 
    public int year; 
    public int month; 
    public int day;

 public Date(int year, int month, int day) {
  this.year = year; 
        this.month = month; 
        this.day = day;
    }

public void printDate(){
        System.out.println(year + "-" + month + "-" + day); 
    }

 public static void main(String[] args) {
        // 如果编译器会生成，则生成的构造方法一定是无参的 
        // 则此处创建对象是可以通过编译的
        // 但实际情况是：编译期报错
        Date d = new Date();
        d.printDate();
    }


/*
Error:(26, 18) java: 无法将类 extend01.Date中的构造器 Date应用到给定类型; 
  需要: int,int,int
  找到: 没有参数
  原因: 实际参数列表和形式参数列表长度不同
*/

  构造方法中，可以通过this调用其他构造方法来简化代码
  this(...)必须是构造方法中第一条语句
  不能形成环

public class Date { 
    public int year; 
    public int month; 
    public int day;

    // 无参构造方法--内部给各个成员赋值初始值，该部分功能与三个参数的构造方法重复 
    
    // 此处可以在无参构造方法中通过this调用带有三个参数的构造方法
    
    // 但是this(1900,1,1);必须是构造方法中第一条语句
    
    public Date(){
        //System.out.println(year);   注释取消掉，编译会失败
        this(1900, 1, 1);

        //this.year = 1900; 
        //this.month = 1; 
        //this.day = 1;
    }

    // 带有三个参数的构造方法
    public Date(int year, int month, int day) { 
        this.year = year;
        this.month = month;
        this.day = day;
    }
}

public Date(){ 
   this(1900,1,1);
}

public Date(int year, int month, int day) { 
   this();
 }
 
/*
  无参构造器调用三个参数的构造器，
  而三个参数构造器有调用无参的构造器，
  形成构造器的递归调用 
编译报错：Error:(19, 12) java: 递归构造器调用

*/

五、封装

1. 封装

面向对象程序三大特性：封装、继承、多态。
而类和对象阶段，主要研究的就是封装特性。
何为封装呢？简单来说就是套壳屏蔽细节。

将数据和操作数据的方法进行有机结合，
隐藏对象的属性和实现细节，
仅对外公开接口来和对象进行交互。

2. 访问限定符

Java中主要通过类和访问权限来实现封装：
类可以将数据以及封装数据的方法结合在一起，
更符合人类对事物的认知，
而访问权限用来控制方法或者字段能否直接在类外使用。
Java中提供了四种访问限定符：
一般情况下成员变量设置为private，成员方法设置为public。
在这里插入图片描述

3. 包

为了更好的管理类，把多个类收集在一起成为一组，称为软件包。
在Java中也引入了包，包是对类、接口等的封装机制的体现，
是一种对类或者接口等的很好的组织方式，
比如：一个包中的类不想被其他包中的类使用。

包还有一个重要的作用：
在同一个工程中允许存在相同名称的类，
只要处在不同的包中即可。

4. 导入包中的类

使用 import语句导入包。

import java.util.Date;
public class Test {
    public static void main(String[] args) { 
        Date date = new Date();
        // 得到一个毫秒级别的时间戳 
        System.out.println(date.getTime()); 
    }
  }

如果需要使用 java.util 中的其他类,
可以使用 import java.util.*

import java.util.*; 
public class Test { 
    public static void main(String[] args) {
        Date date = new Date();
        // 得到一个毫秒级别的时间戳 
        System.out.println(date.getTime()); 
    }
 }

更建议显式的指定要导入的类名,
否则还是容易出现冲突的情况

import java.util.*; 
import java.sql.*; 
public class Test { 
    public static void main(String[] args) {
        // util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错 
        Date date = new Date();
        System.out.println(date.getTime());
    }
}

// 编译出错
Error:(5, 9) java: 对Date的引用不明确
  java.sql 中的类 java.sql.Date 和 java.util 中的类 java.util.Date 都匹配



在这种情况下需要使用完整的类名
import java.util.*; 
import java.sql.*; 
public class Test { 
    public static void main(String[] args) {
        java.util.Date date = new java.util.Date(); 
        System.out.println(date.getTime());
    }
}

可以使用import static导入包中静态的方法和字段。

import static java.lang.Math.*;
public class Test {
    public static void main(String[] args) { 
        double x = 30;
        double y = 40;

        // 静态导入的方式写起来更方便一些.
        // double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2)); 
        double result = sqrt(pow(x, 2) + pow(y, 2)); 
        System.out.println(result);
    }
}

5. 自定义包

在文件的最上方加上一个 package 语句指定该代码在哪个包中.

包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式

包名要和代码路径相匹配.
例如创建 com.bit.demo1 的包,
那么会存在一个对应的路径 com/bit/demo1 来存储代码.

如果一个类没有 package 语句, 则该类被放到一个默认包中.

6. 常见的包

java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。
java.lang.reﬂect:java 反射编程包;
java.net:进行网络编程开发包。
java.sql:进行数据库开发的支持包。
java.util:是java提供的工具程序包。(集合类等) 非常重要
java.io:I/O编程开发包。

六、 static成员

在Java中，被static修饰的成员，
称之为静态成员，也可以称为类成员，
其不属于某个具体的对象，
是所有对象所共享的。

1. static修饰成员变量

static修饰的成员变量，称为静态成员变量，静态成员变量最大的特性：
不属于某个具体的对象，是所有对象所共享的。

不属于某个具体的对象，是类的属性，
所有对象共享的，
不存储在某个对象的空间中。
既可以通过对象访问，也可以通过类名访问，
但一般更推荐使用类名访问。
类变量存储在方法区当中。
生命周期伴随类的一生
(即：随类的加载而创建，随类的卸载而销毁)

 public class Student{
    public String name;
    public String gender;
    public int  age;
    public double score;
    public static String classRoom = "Bit306";
    
    // ...
    
    public static void main(String[] args) {
    
        // 静态成员变量可以直接通过类名访问
        System.out.println(Student.classRoom);

 

        Student s1 = new Student("Li leilei", "男", 18, 3.8);
        Student s2 = new Student("Han MeiMei", "女", 19, 4.0);
        Student s3 = new Student("Jim", "男", 18, 2.6);

 

        // 也可以通过对象访问：但是classRoom是三个对象共享的
        System.out.println(s1.classRoom);
        System.out.println(s2.classRoom);
        System.out.println(s3.classRoom);
    }
}

2. static修饰成员方法

被static修饰的成员方法称为静态成员方法，是类的方法，
不是某个对象所特有的。

可以通过对象调用，也可以通过类名.静态方法名(…)方式调用，更推荐使用后者

静态成员一般是通过静态方法来访问的。

不能在静态方法中访问任何非静态成员变量

静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用

public class Student{
    // ...
    
    private static String classRoom = "306";
    
    // ...
    
    public static String getClassRoom(){
        return classRoom;
    }

}

public class TestStudent {
    public static void main(String[] args) {
    
        // 过静态方法来访问的
        System.out.println(Student.getClassRoom());
    }
}

输出: 306

public static String getClassRoom(){
    System.out.println(this);
    return classRoom;

}

 
// 编译失败：Error:(35, 28) java: 无法从静态上下文中引用非静态 变量 this

 
public static String getClassRoom(){
    age += 1;
    return classRoom;
}


// 编译失败：Error:(35, 9) java: 无法从静态上下文中引用

public static String getClassRoom(){
    doClass();
    return classRoom;

}

// 编译报错：Error:(35, 9) java: 无法从静态上下文中引用非静态 方法 doClass()

3. static成员变量初始化

静态成员变量的初始化分为两种：
就地初始化和静态代码块初始化。

就地初始化指的是：在定义时直接给出初始值

public class Student{
    private String name;
    private String gender;
    private int  age;
    private double score;
    private static String classRoom = "Bit306";  
    
    // ...
}

七、代码块

1. 普通代码块

定义在方法中的代码块.

public class Main{
    public static void main(String[] args) {
        { //直接使用{}定义，普通方法块
            int x = 10 ;
            System.out.println("x1 = " +x);
        }
        int x = 100 ;
        System.out.println("x2 = " +x);
    }

}

 

// 执行结果
x1 = 10
x2 = 100

2. 构造代码块

定义在类中的代码块(不加修饰符)。
也叫：实例代码块。
构造代码块一般用于初始化实例成员变量。

public class Student{

    // 实例成员变量
    private String name;
    private String gender;
    private  int age;
    private double score;
    
    public Student() {
        System.out.println("I am Student init()!");
    }
    
    // 实例代码块
    {
        this.name = "bit";
        this.age = 12;
        this.sex = "man";
        System.out.println("I am instance init()!");
    }
    
    public void show(){
        System.out.println("name: "+name+" age: "+age+" sex: "+sex);
    }
}

public class Main {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.show();
    }
}

 

// 运行结果
I am instance init()!
I am Student init()!
name: bit age: 12 sex: man

3. 静态代码块

使用static定义的代码块称为静态代码块。
一般用于初始化静态成员变量。

静态代码块不管生成多少个对象，其只会执行一次

静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的

如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)

实例代码块只有在创建对象时才会执行

public class Student{

    private String name;
    private String gender;
    private int  age;
    private double score;
    private static String classRoom;

 
    //实例代码块
    {
        this.name = "bit";
        this.age = 12;
         this.gender = "man";
        System.out.println("I am instance init()!");
    }


    // 静态代码块
    static {
        classRoom = "bit306";
        System.out.println("I am static init()!");
    }

 
    public Student(){
        System.out.println("I am Student init()!");
    }

 
    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 = new Student();
    }
}

八、内部类

当一个事物的内部，
还有一个部分需要一个完整的结构进行描述，
而这个内部的完整的结构又只为外部事物提供服务，
那么整个内部的完整结构最好使用内部类。

在 Java 中，可以将一个类定义在另一个类或者一个方法的内部,前者称为内部类，后者称为外部类。

内部类和外部类共用同一个java源文件，但是经过编译之后，内部类会形成单独的字节码文件。

public class OutClass {
    class InnerClass{

    }
}


// OutClass是外部类
// InnerClass是内部类


定义在class 类名{}花括号外部的，即使是在一个文件里，都不能称为内部类
public class A{
    

}

class B{
    

}

// A 和 B是两个独立的类，彼此之前没有关系

1. 实例内部类

未被static修饰的成员内部类。

外部类中的任何成员都可以在实例内部类方法中直接访问。

实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束。

在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名称.this.同名成员来访问。

实例内部类对象必须在先有外部类对象前提下才能创建

实例内部类的非静态方法中包含了一个指向外部类对象的引用。

外部类中，不能直接访问实例内部类中的成员，
如果要访问必须先要创建内部类的对象。

 public class OutClass {
 
   private int a;
   static int b;
   int c;
   
   public void methodA(){
       a = 10;
       System.out.println(a);
   }


   public static void methodB(){
       System.out.println(b);
   }


   //  实例内部类：未被static修饰
   class InnerClass{
       int c;
       
       public void methodInner(){
           // 在实例内部类中可以直接访问外部类中：任意访问限定符修饰的成员
           a = 100;
           b =200;
           methodA();
           methodB();


           // 如果外部类和实例内部类中具有相同名称成员时，优先访问的是内部类自己的
           c = 300;
           System.out.println(c);


           // 如果要访问外部类同名成员时候，必须：外部类名称.this.同名成员名字
           OutClass.this.c = 400;
           System.out.println(OutClass.this.c);
       }
   }



   public static void main(String[] args) {
   
       // 外部类：对象创建 以及 成员访问
       OutClass outClass = new OutClass();
       System.out.println(outClass.a);
       System.out.println(OutClass.b);
       System.out.println(outClass.c);
       outClass.methodA();
       outClass.methodB();



       System.out.println("=============实例内部类的访问=============");
       
       // 要访问实例内部类中成员，必须要创建实例内部类的对象
       
       // 而普通内部类定义与外部类成员定义位置相同，因此创建实例内部类对象时必须借助外部类



       // 创建实例内部类对象
       OutClass.InnerClass innerClass1 = new OutClass().new InnerClass();



       // 上述语法比较怪异，也可以先将外部类对象先创建出来，然后再创建实例内部类对象
       
       OutClass.InnerClass innerClass2 = outClass.new InnerClass();
       innerClass2.methodInner();
   }

2.静态内部类

被static修饰的内部成员类称为静态内部类。

在静态内部类中只能访问外部类中的静态成员。

创建静态内部类对象时，不需要先创建外部类对象

public class OutClass {
   private int a;
   static int b;
   public void methodA(){
       a = 10;
       System.out.println(a);
   }



   public static void methodB(){
       System.out.println(b);
   }



   // 静态内部类：被static修饰的成员内部类
   static class InnerClass{
       public void methodInner(){
           // 在内部类中只能访问外部类的静态成员
           // a = 100;      // 编译失败，因为a不是类成员变量
           b =200;
           // methodA();    // 编译失败，因为methodB()不是类成员方法
           methodB();
       }
   }



   public static void main(String[] args) {
       // 静态内部类对象创建 & 成员访问
       OutClass.InnerClass innerClass = new OutClass.InnerClass();
       innerClass.methodInner();
   }
}

3. 局部内部类

局部内部类只能在所定义的方法体内部使用。

不能被public、static等修饰符修饰。

编译器也有自己独立的字节码文件，命名格式：外部类名字$内部类名字.class。

几乎不会使用。

public class OutClass {
    int a = 10;
    public void method(){
        int b = 10;
        

        // 局部内部类：定义在方法体内部
        // 不能被public、static等访问限定符修饰
        class InnerClass{
            public void methodInnerClass(){
                System.out.println(a);
                System.out.println(b);
            }
        }

 
        // 只能在该方法体内部使用，其他位置都不能用
        InnerClass innerClass = new InnerClass();
        innerClass.methodInnerClass();
    }


    public static void main(String[] args) {
        // OutClass.InnerClass innerClass = null; 编译失败
    }
}

4. 匿名内部类

九、对象的打印

重写toString方法即可默认打印对象中的属性。

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

 
    public Person(String name, String gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
    }

 
    @Override
    public String toString() {
        return "[" + name + "," + gender + "," + age + "]";
    }

 
    public static void main(String[] args) {
        Person person = new Person("Jim","男", 18);
        System.out.println(person);
    }
}

 

// 输出结果：[Jim,男,18]

汪汪miao~

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java——类和对象

面相对象程序设计关注的是对象，而对象是现实生活中的实体，类是用来对一个实体(对象)来进行描述的，主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能，描述完成后计算机就可以识别了。上图左侧就是对洗衣机简单的描述，该过程称为对洗衣机对象(实体)进行抽象(对一个复杂事物的重新认知)，但是这些简化的抽象结果计算机也不能识别，开发人员可以采用某种面相对象的编程语言来进行描述，比如：Java语言。// 创建类field;// 字段(属性) 或者成员变量method;
复制链接

扫一扫