JAVA基础知识——类与对象

最新推荐文章于 2023-11-29 12:47:41 发布

liuchunyv711

最新推荐文章于 2023-11-29 12:47:41 发布

阅读量340

点赞数

分类专栏： JAVA学习文章标签： java

本文链接：https://blog.csdn.net/liuchunyv711/article/details/105594925

版权

JAVA学习专栏收录该内容

4 篇文章 0 订阅

订阅专栏

1、定义

2、静态属性和方法

3、访问实例变量和方法

4、重写(Override)与重载(Overload)

5、Java包管理

1、定义

面向对象思想：先整体，再局部；先抽象，再具体；能做什么，再怎么做。

类：类是一个类别，一个模板，它描述一类对象的行为和状态，是一组具有相同特性（属性）与行为（方法）的事物集合。

一个类可以包含以下类型变量：

局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
类变量：类变量也声明在类中，方法体之外，但必须声明为static类型。

对象：是一个个性的产物，是一个个体的特征，是类的一个实例，有状态和行为。

举例：

public class People {//人这个类
    String name;//姓名属性
    String sex;//性别属性
    int  age;//年龄属性

    public void eat(){//方法-吃

    }
    public void run(){//方法-跑

    }
    public void think(){//方法-思考

    }
    public People(){//无参构造方法
    }

    public People(String name){
        // 这个构造器仅有一个参数：name
    }

}

2、属性和方法

属性和方法：软件对象也有状态和行为。软件对象的状态就是属性，行为通过方法体现。举例说明，比如人是一个类，小明就是一个具体的对象，人有年龄，性别，姓名等，这些就是属性，人可以有跑，思考，吃饭等动作，就是人可以干什么，就称之为方法。

    修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}

方法包含一个方法头和一个方法体。下面是一个方法的所有部分：

修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。

返回值类型：方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType 是关键字void。

方法名：是方法的实际名称。方法名和参数表共同构成方法签名。

参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。

方法体：方法体包含具体的语句，定义该方法的功能。

构造方法：每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法。在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。

方法调用：Java 支持两种调用方法的方式，根据方法是否返回值来选择。当程序调用一个方法时，程序的控制权交给了被调用的方法。当被调用方法的返回语句执行或者到达方法体闭括号时候交还控制权给程序。当方法返回一个值的时候，方法调用通常被当做一个值。

2、静态属性和方法

静态属性：当一个属性被static修饰的时候，就叫做类属性，又叫做静态属性。当一个属性被声明成类属性，那么所有的对象，都共享一个值。
与对象属性对比：不同对象的对象属性的值都可能不一样。比如Mike和Cindy的姓名是不一样；但是所有对象的类属性的值，都是一样的，如果一个属性声明成类属性，那么所有的对象，都共享这么一个值。

访问类属性有两种方式：类.类属性；对象.类属性

静态方法：又叫做类方法，访问类方法，不需要对象的存在，直接就访问
对象方法：又叫实例方法，非静态方法，访问一个对象方法，必须建立在有一个对象的前提的基础上

和访问类属性一样，调用类方法也有两种方式：类.类方法；对象.类方法

举例：

public class People {//人这个类
    //对象属性初始化有3种，以下分别标识为1，2，3
    String name = "some one";//姓名属性,对象属性初始化1声明该属性的时候初始化
    String sex;//性别属性
    int  Age;//年龄属性
    static String star;//类属性,静态属性,说明来自哪个星球
    //类方法，静态方法
    //通过类就可以直接调用
    public static void sleep(){
        System.out.println("睡觉");
    }
    //普通方法
    public void run(){
        System.out.println("跑步");
    }
    public static void main(String[] args){
        /* 创建对象 */
        People cindy = new People();
        cindy.name = "Cindy";
        People.star = "地球";
        System.out.println(People.star);//访问类属性,类.类属性
        System.out.println(cindy.star);//访问类属性,对象.类属性

        cindy.run();//必须有一个对象才能调用
        People.sleep();//无需对象，直接通过类调用
    }

}

3、访问实例变量和方法

创建对象

引用：如果一个变量的类型是类类型，而非基本类型，那么该变量又叫做引用。

new关键字：表示向内存申请空间，也表示实例化一个对象，创建一个对象；不同的引用，指向同一个对象，任何一个引用改变对象的值，其它引用都会反映出来；当一个堆中的对象没有被任何引用变量所指向时，该对象会被JVM 的 GC 程序认为是垃圾对象，从而被回收

对象是根据类创建的。在Java中，使用关键字new来创建一个新的对象。创建对象需要以下三步：声明：声明一个对象，包括对象名称和对象类型；实例化：使用关键字new来创建一个对象；初始化：使用new创建对象时，会调用构造方法初始化对象。

访问实例变量和方法

通过已创建的对象来访问成员变量和成员方法

代码举例

public class People {//人这个类
    //对象属性初始化有3种，以下分别标识为1，2，3
    String name = "some one";//姓名属性,对象属性初始化1声明该属性的时候初始化
    String sex;//性别属性
    int  Age;//年龄属性
    public People(){//无参构造方法
        sex = "男";//对象属性初始化2构造方法中初始化
    }
    public People(String name){
        // 这个构造器仅有一个参数：name
        System.out.println("名字是 : " + name );
    }
    {
        Age = 20;//对象属性初始化3初始化块
    }
    public void setAge( int age ){
        Age = age;
    }

    public int getAge( ){
        System.out.println("年龄为 : " + Age );
        return Age;
    }
    public static void main(String[] args){
        /* 创建对象 */
        People cindy = new People("Cindy");//带一个参数的构造方法
        People mike = new People();//无参构造方法
        /* 通过方法来设定age ,传入参数18*/
        cindy.setAge( 18 );
        /* 调用另一个方法获取age */
        cindy.getAge( );
        /*也可以像下面这样访问成员变量 */
        System.out.println("变量值 : " + cindy.Age );
    }

}

this关键字用法

通俗来说，this这个关键字，相当于普通话里的“我”，小明说 “我吃了” 这个时候，“我” 代表小明；小红说 “我吃了” 这个时候，“我” 代表小红。"我"代表当前人物，this即代表当前对象

this关键字代表当前对象，打印this会显示该对象在内存中的虚拟地址；通过this关键字还可以访问对象的属性以及在一个构造方法中，调用另一个构造方法

简单应用示例

public class People {//人这个类
    //对象属性初始化有3种，以下分别标识为1，2，3
    String name = "some one";//姓名属性,对象属性初始化1声明该属性的时候初始化
    String sex;//性别属性
    int  Age;//年龄属性

    /* this代表当前对象 */
    //打印内存中的虚拟地址
    public void showAddressInMemory(){
        System.out.println("打印this看到的虚拟地址："+this);
    }

    /* 通过this访问属性 */
    //参数名和属性名一样
    //在方法体中，只能访问到参数name
    public void setName1(String name){
        name = name;
    }

    //为了避免setName1中的问题，参数名不得不使用其他变量名
    public void setName2(String heroName){
        name = heroName;
    }

    //通过this访问属性
    public void setName3(String name){
        //name代表的是参数name
        //this.name代表的是属性name
        this.name = name;
    }

    /*通过this调用其他的构造方法 */
    //带一个参数的构造方法
    public People(String name){
        System.out.println("一个参数的构造方法");
        this.name = name;
    }

    //带两个参数的构造方法
    public People(String name,int age){
        this(name);//通过this调用其他的构造方法
        System.out.println("两个参数的构造方法");
        this.Age = age;
    }

}

4、重写(Override)与重载(Overload)

重写：是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常

class Animal {//父类
    void eat() {//父类eat()方法
        System.out.println("animal : eat");
    }
}

class Dog extends Animal {//Dog类继承自Animal父类
    void eat() {//子类重写父类eat()方法
        System.out.println("dog : eat");
    }
}

方法的重写规则

参数列表必须完全与被重写方法的相同。
返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类（java5 及更早版本返回类型要一样，java7 及更高版本可以不同）。
访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。
父类的成员方法只能被它的子类重写。
声明为 final 的方法不能被重写。
声明为 static 的方法不能被重写，但是能够被再次声明。
子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。
子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
构造方法不能被重写。
如果不能继承一个方法，则不能重写这个方法。

重载：是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。最常用的地方就是构造器的重载。

public class Overloading {
    public int test(){
        System.out.println("test1");
        return 1;
    }

    public void test(int a){
        System.out.println("test2");
    }

    //以下两个参数类型顺序不同
    public String test(int a,String s){
        System.out.println("test3");
        return "returntest3";
    }

    public String test(String s,int a){
        System.out.println("test4");
        return "returntest4";
    }

    public static void main(String[] args){
        Overloading o = new Overloading();
        System.out.println(o.test());
        o.test(1);
        System.out.println(o.test(1,"test3"));
        System.out.println(o.test("test4",1));
    }
}

重载规则:

被重载的方法必须改变参数列表(参数个数或类型不一样)；
被重载的方法可以改变返回类型；
被重载的方法可以改变访问修饰符；
被重载的方法可以声明新的或更广的检查异常；
方法能够在同一个类中或者在一个子类中被重载。
无法以返回值类型作为重载函数的区分标准。

5、Java包管理

为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。

包的作用：1、把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用；2、如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突；3、包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

Java 使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等

包语句的语法格式为：package pkg1．pkg2．pkg3…;

import 关键字

为了能够使用某一个包的成员，我们需要在 Java 程序中明确导入该包。使用 "import" 语句可完成此功能。

在 java 源文件中 import 语句应位于 package 语句之后，所有类的定义之前，可以没有，也可以有多条

其语法格式为：import package1.package2….classname;

package 的目录结构

....\com\pkg\demo\Test.java

// 文件名: Test.java
 
package com.pkg.demo;
public class Test {

}

今天也是努力整理知识点的一天，有什么不足欢迎大家指正，学习参考网站

https://www.runoob.com/java/java-tutorial.html

https://how2j.cn/