Java对象与Java类

Posted 2021-08-29 KookNut39

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java对象与Java类相关的知识，希望对你有一定的参考价值。

大家好，我是KookNut39也是Tommy，在CSDN写文，写Java时候我是Tommy，分享一些自己认为在学习过程中比较重要的东西，致力于帮助初学者入门，希望可以帮助你进步。感兴趣的欢迎关注博主，和博主一起学习Java知识。大家还可以去专栏查看之前的文章，希望未来能和大家共同探讨技术。

面向对象程序设计是当今主流的程序设计范型，它取代了20世纪70年代的“结构化”或过程式编程技术。

——Java核心技术卷1（11版）

由于Java是面向对象的，所以我们必须熟悉面向对象程序设计才能更好的使用Java

1.面向对象是什么?

面向对象：object oriented programming 缩写 OOP面向对象的编程语言

以分类的方式进行思考和解决问题。
面向对象先对整体关系作出分类，然后根据不同的类深入细节的处理。
面向对象的思想符合人类的认知习惯。

我见过举的最多的例子就是把大象放进冰箱：

面向对象的思想就是把这件事的三个步骤：打开冰箱，放入大象，关闭冰箱。这三个动作俩个是关于冰箱的，一个是关于操作人的。所以就把打开冰箱，关闭冰箱这俩个操作定义在冰箱这个对象中，把放入大象定义在人这个对象中。于面向过程不同的就是在，面向过程关注的是正在发生什么事，面向对象关注的是发生这件事和谁有关系。

面向对象的程序是由对象组成的，每个对象包含对用户公开的特定功能部分和隐藏的实现部分。

——Java核心技术卷1（11版）

注意

面向对象无法取代面向过程，他们是相辅相成的。面向对象关注于从宏观上把握事物之间的关系，在具体到如何实现某个细节时（在类中定义一个方法），仍然采用面向过程的思维方式。

对于一些规模较小的问题，将它分解为过程的开发方式比较理想，面向对象的设计思想适用于规模较大的项目，把很多个过程转换为较少的类，这更便于程序员管理，寻找错误时与比较方便（假设一个数据出现了错误，你只需要找访问这个数据的方法）。

2.Java类

1.什么是类

类是构造对象的模板或蓝图，我们可以将类想象成制作小甜饼的模具，将对象想象为小甜饼。

——Java核心技术卷1（11版）

也就是说：

类就是将一类事物的相同的属性，行为放在一起
类是表示一个客观世界某类群体的一些基本特征抽象.

2.Java类

类的结构

变量：事物属性的描述；

方法:事物的行为；（可以做的事情）

构造方法：用于创建对象；(创建类的时候有一个默认的无参的构造方法)

内部类：即在类体中声明的类。

块：一段没有名称的代码块

Java类的格式

[访问权限修饰符]  [修饰符] class Person{
//第一步声明一个类
  /*访问修饰符有两种public，无(默认)

  修饰符：final,abstract

  关键字class用来定义一个类
    
  Java类名的命名规范:

  类名首字母大写,见名知意,驼峰表示*/
//第二步给类添加属性
    //成员变量定义
    /*
    [访问权限修饰符] [修饰符] 属性类型 属性名;
    */
    public String name; //名字
    public Integer age; //年龄
//第二步给类添加方法
    /*方法声明格式为:
    [访问权限修饰符] [修饰符] 返回值类型  方法名(){
	
     }*/
     public void eat(){
         System.out.println("吃饭");
     }

}

3.java对象

对象是类的一个实例，是以类为模板在内存中创建的实际存在的实例

上面举得例子人就是一个类，我们每个人都是一个对象，拥有类中的属性，行为，可以使用。

对象的创建和使用：

Person person = new Person();

Person person：使用Person类作为类型声明一个变量person（对象变量）。

new Person()：使用new + Person 类构造方法创建对象.

=：将右边创建的对象地址赋给左边的person变量

使用person变量可以访问对象中的成员变量和成员方法.

注意：

同一类的每个对象有不同的成员变量存储空间。
同一类的每个对象共享该类的方法。

要想使用对象，必须清楚对象的三个主要特征：

对象的行为：可以对对象完成哪些操作，或者可以对对象应用哪些方法。
对象的状态：当调用那些方法时，对象会怎么样。
对象的标识：如何区分具有相同行为与状态的不同对象。

4.类和对象

类是一类事物的抽象概念，是一个模型

对象是由这个模型所创造的一个个具体存在的，实实在在存在的实例。

所以创建对象的过程也叫实例化对象。

编程中现有类后有对象。

现实生活中先有对象后有类（相当于根据对象，总结出来的类）。

5.类中的变量，方法

1.变量分类

按照位置分

成员变量：

成员变量是定义在类中，方法体之外的变量。

成员变量可以使用Java语言中任何一种数据类型（包括基本类型和引用类型）。

在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。

成员变量在创建对象的时候会从类中复制一份到对象中。

成员变量可以被类中方法、构造方法和特定类的语句块访问。

成员变量的作用范围为整个类体。

局部变量：

在方法、构造方法或者语句块中定义的变量被称为局部变量。

局部变量可以使用Java语言中任何一种数据类型（包括基本类型和引用类型）。

局部变量在使用前必须初始化赋值。

变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。

2.方法分类

成员方法：成员方法是定义在类中。这种方法在创建对象的时候创建。

语法格式：

修饰符 返回值类型 方法名(参数列表) {

    方法体语句；

    [return 返回值]
}

构造方法：用来创建对象的方法

构造方法名与类名相同,且没有返回值，且不需要使用void修饰。

构造方法是定义在 Java 类中的一个用来创建对象的方法。

使用 new + 构造方法 创建一个新的对象。在创建一个对象的时候，至少要调用一个构造方法。

每个类都有构造方法。如果没有显式地为类定义构造方法，Java将会为该类提供一个默认构造方法，但是只要在一个Java类中定义了一个显示的构造方法后，默认的无参构造方法即失效。

一个类可以有多个构造方法。

public class Person{ 

  public Person(){ 
  } 

  public Person(String name){ 
      // 这个构造方法有一个参数：name 
  } 

}

例：创建Person类的对象

Person person= new Person();

Person person = new Person("张三")；

6.方法重载

方法的重载是指同一个类中具有相同的名字，但参数不同的几个方法。

参数不同（可以有三方面的不同）

数量不同
类型不同
顺序不同

调用时，会根据不同的参数表选择对应的方法。

注意：方法重载跟方法的返回值类型没有任何关系

7.对象与引用

Java 语言中除基本类型之外的变量类型都称之为引用类型。

Java中的对象是通过引用对其操作的。

 class Person{    
    String name;
    String age;
}

Person person= new Person();

创建一个对象包含三个动作:

右边的“new Person()”，是以Person类为模板,调用Person类的构造方法,在堆空间里创建一个Person类对象。
左边的“Person person”创建了一个Person类型引用变量。所谓Person类的引用，就是以后可以用来指向Person对象的对象引用。
”=”操作符使对象引用指向刚创建的那个Person对象。

Person person;//对象引用变量
            
person= new Person();//对象本身

new Person(); 这个语句在堆空间里创建了实体，尽管它们也是确确实实存在的实体，但是，我们看不见，也摸不着。

对象没有名字，也就没法直接访问它。我们需要通过对象引用来间接访问对象。

对象好比是一只很大的气球，但是我们抓不住它。引用变量是一根绳，可以用来系汽球。

Person  person1; //创建一根绳子，一根还没有系上任何一个气球的绳；

Person  person2;//又做了一根绳，还没系上气球，

person1 = new Person();//给person1系上气球；

person2 = person1；//这里，发生了复制行为。要说明的是，对象本身并没有被复制，被复制的只是对象引用。

结果是，person2也指向了person1所指向的对象。两根绳系的是同一只气球。

基本类型和引用类型的区别:

基本类型

byte,short,int,long,float,double,char,boolean

它的值就是一个数字，一个字符或一个布尔值.

引用数据类型

类,接口,数组

它的值是对象在内存空间中的地址,

值传递与引用传递

Java中进行方法调用中传递参数时，参数传递有两种：

值传递：(形式参数类型是基本数据类型)：方法调用时，实际参数把它的值传递给对应的形式参数，形式参数只是用实际参数的值初始化自己的存储单元内容，是两个不同的存储单元，所以方法执行中形式参数值的改变不影响实际参数的值。
引用传递：(形参数类型是引用数据类型参数)：也称为传地址。方法调用时，实际参数是对象，这时实际参数与形式参数指向同一个地址，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，这个结果在方法结束后被保留了下来，所以方法执行中形式参数的改变将会影响实际参数。

基本类型传递的是该数据值本身。引用类型传递的是对对象的引用，而不是对象本身。

8.static关键字

概念

static被称为静态，可以用来修饰类的属性,方法,代码块,内部类。
随着类的加载而加载
优先于对象存在
修饰的成员，被所有对象所共享
可不创建对象，直接被类调用

static属性

静态属性是类的所有对象共享的，不管创建了多少个对象，静态属性在内存中只有一个。

static方法

可以使用对象调用，也可以直接用类名调用，建议用类名直接调用

在static方法内部只能访问类的static属性，不能访问类的非static属性，因为static属性先加载。

因为在类加载的时候加载方法，非static属性还没有加载，如果在静态方法中访问非static属性，该属性找不到。

代码块

代码块在类中声明，类似一个没有名称的方法体(代码块)，代码分实例块和静态块

//实例块：每次创建对象时自动调用
{

   //任何符合语法的Java代码

}

//静态块：类加载时自动调用，仅一次，与是否创建对象无关。  
static {

    //任何符合语法的Java代码

}

9.类的加载执行

创建对象时，先执行静态代码块，在执行实例代码块，然后执行构造方法。

10.包

包的概念：

包就相当于一个文件夹

包的作用：

避免类重名

按照不同功能管理类

控制访问权限

包（package）的命名规范：

在包名中，可以使用 . 号来区分包的级别；包名一般情况下是小写

第一级指该项目的类型，如com等，
第二级指项目所开发或者运行的公司名称，如：oracle,sun,huawei等
第三级指项目的名称。
第四级指项目模块的名称。如：filter等表明这个包下类的功能

包可以更好得管理逻辑相关的类，可以控制不同包之间的访问权限

导入外部包的类，关键字import

访问权限修饰符

Java语言有四个权限访问修饰符，权限从大到小依次为：

public ：公共权限 修饰类、属性、方法。可以被任意类访问
protected：受保护的权限 修饰属性、方法。可以被同包类访问，如果不是同包类，必须是该类的子类才可以访问。
default：同包权限 修饰类、属性、方法。只能被同包的类访问
private：私有权限 修饰属性、方法。只能在本类中访问

11.面向对象语言的三大特征

1.封装

封装：有时称之为数据隐藏，将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问

好处：隐藏类的实现细节，方便加入控制语句，方便修改实现

具体表现是

属性使用private权限（私有的）

方法使用public权限

例子：

public class Person {    
    private String name;    
    private String age;    
    public String getName() {        
        return name;    
    }    
    public void setName(String name) {        
        this.name = name;   
    }   
    public String getAge() {        
        return age;    
    }    
    public void setAge(String age) {        
        this.age = age;    
    }
}

我们可以发现上述代码用到了this关键字，那么什么是this关键字呢？

this关键字代表自身类的对象

功能：

使用this关键字引用成员变量
使用this关键字引用成员方法

注意：this关键字必须放在非静态方法里面

在一个类的方法或构造方法内部，可以使用“this.成员变量名”这样的格式来引用成员变量名，常常用来区分同名的成员变量和局部变量。

例如上面的：

 this.name = name;   //把局部变量赋值给自己类的成员变量

2.多态

多态是同一个行为具有多个不同表现形式或形态的能力

多态的优点

消除类型之间的耦合关系
可替换性
可扩充性
接口性
灵活性
简化性

多态存在的三个必要条件

继承
重写
父类引用指向子类对象：Parent p = new Child();（Child类继承了Parent 类）

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

public class Test {
    public static void main(String[] args) {
        show(new Cat());  
        show(new Dog());  
    }  
    public static void show(Animal a)  {
        a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  
            Cat c = (Cat)a;  //向下转型
            c.work();  
        } else if (a instanceof Dog) { 
            Dog c = (Dog)a;  
            c.work();  
        }  
	}  
}

public abstract class Animal {  
    abstract void eat();  
}  

public class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}

public class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

Test中的main方法输出：

同一个方法在不同情况下的表现不同，就是多态的体现。

3.继承

继承：继承是面向对象程序设计不可缺少的设计思想，是实现代码可重用的根基，是提高代码可扩展性的主要途径。

继承是从已有的类中派生出新的类，新的类能吸收已有类的属性和行为，并能扩展新的能力。

在JAVA中使用extends关键字来表示继承关系。
JAVA不支持多继承，单继承使JAVA的继承关系很简单，一个类只能有一个直接父类。
继承之后子类可以调用父类的所有非私有属性和非私有方法。

什么时候使用继承呢？

当你想用一些非本类的方法或属性时，可以使用继承，继承想使用的那个类，就可以将那个类中的属性方法拿过来用，可以让你少写一些代码。所以继承是代码重用的一种方式

public class Animal{

  public static void eat(){
            System.out.println("动物吃");
        }

}
public class Dog  extends Animal{

 public static   void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();
    }

}

专业术语：

Dog类是 Animal类的子类, Animal类是Dog类的父类（或者是） Dog类是 Animal类的派生类, Animal类是Dog类的基类。

继承的传递性

C类从B类继承,B类又从A类继承

那么C类就具有B类和A类的所有非私有的属性和方法

当一个没有继承任何一个类时，jvm（java虚拟机）会默认让类继承Object类

Object是 java为所有类提供的基类

继承中的构造方法

子类构造方法总是先调用父类构造方法，默认情况下，调用父类无参构造方法

可以在子类构造方法的第一行，使用super关键字调用父类任意一个构造方法

如果用super，必须写在方法的第一行

如果子类的构造方法中没有显式地（使用super）调用基类构造方法，则系统默认调用基类无参数的构造方法。

为什么要先创建父类：子类创建后需要调用父类的方法,所以在创建子类对象是父类也需要同时被创建.

我们又提到了一个新的关键字——super

super关键字用途

super关键字代表父类的引用，在程序中主要的用途
在子类构造方法中要调用父类的构造方法，需要注意：super语句只能出现在子类构造方法体的第一行。
用“super.成员变量名”来引用父类成员变量。
用“super.方法名（参数列表）”的方式访问父类的方法。
与this的区别，this通常指代当前对象，super通常指代父类。

方法的重写(OverRide)

在子类中可以根据需要对从基类中继承来的方法进行重写。

方法重写规则

方法名相同、参数列表相同；
返回值类型相同；
访问权限等于或大于父类中方法权限;

只有方法体不同（大括弧内的代码不同）

注意：构造方法不能重写

应用场景：

当父类的方法实现不能满足子类需求时,可以对方法进行重写( override)

12.类于类之间的关系

1.关联关系(has-a)

对象和对象之间的连接。在Java中，关联关系的代码表现形式为一个类做为另一个类的属性类型存在。

就是相当于我们在我们的类中定义了一个String类型的属性，那么，我们这个类和String类就是关联关系。

即“有”的关系：”has-a”。

关联关系分为单向关联和双向关联

单向关联： A类关联B类。
双向关联：A类关联B类,B类关联A类;

public class Phone {

     private  Person per;//手机有主人

}

public  class Person {

     private Phone phone;//人拥有手机

}

关联关系的多重性

一对一关联：一个手机只能有一个主人

一对多关联：一个人，可以拥有多个手机。

解决一对多的关联的方案：集合或者数组

public List<Phone> phoneList;//集合
public Phone[] phones;//数组

2.依赖关系(uses-a)

依赖关系是指一个类A使用到了另一个类B，也就是说一个类的方法使用或者操作另一个类的对象

依赖关系的特性：

这种关系是具有偶然性的、临时性的、非常弱的，但是类B的变化会影响到类A。

依赖具体表现

在代码层面，依赖关系表现为类B作为参数被类A在某个方法中使用

例：

public  class Person {

      public void travel(Bus bus){}

}

注意：

应该尽量减少类与类之间有这种关系

3.继承关系（is-a）

这种关系在上文中有过解释，在这就不赘述了，写在这只是表明类与类还有这种关系。

本次的分享到这里就结束了，码字不易，如果喜欢，赏个点赞+评论+收藏🤞🤞🤞，感谢您的支持

文中举例，用词等可能有不当的地方，望谅解，欢迎在评论区批评指正！
参考书籍：Java核心技术卷1（11版）

以上是关于Java对象与Java类的主要内容，如果未能解决你的问题，请参考以下文章

Java多线程与并发库高级应用-工具类介绍

JAVA中，类、对象、实体、实体类、实体对象之间存在怎样的联系？？请高手做形象的解释。

Java中super关键字的作用与用法

Java中面向对象的三大特性之封装

Java 封装

elasticsearch代码片段，及工具类SearchEsUtil.java

Java对象与Java类

文章目录

1.面向对象是什么?

2.Java类

1.什么是类

2.Java类

类的结构

Java类的格式

3.java对象

4.类和对象

5.类中的变量，方法

1.变量分类

2.方法分类

6.方法重载

7.对象与引用

基本类型和引用类型的区别:

值传递与引用传递

8.static关键字

概念

static属性

static方法

代码块

9.类的加载执行

10.包

包的概念：

包的作用：

包（package）的命名规范：

访问权限修饰符

11.面向对象语言的三大特征

1.封装

2.多态

3.继承

12.类于类之间的关系

1.关联关系(has-a)

2.依赖关系(uses-a)

3.继承关系（is-a）