JAVA学习面向对象编程入门（一）

最新推荐文章于 2024-04-07 23:54:44 发布

Nanashi_umi

最新推荐文章于 2024-04-07 23:54:44 发布

阅读量160

点赞数 1

文章标签： java

本文链接：https://blog.csdn.net/Nanashi_wumi/article/details/127387853

版权

4.1 面向对象编程简介

4.1.1 面向对象的特点

1.封装性

封装是面向对象的核心思想。将对象的属性和方法封装起来，不让外界知道具体实现的细节，这就是封装的大致描述。将过程与数据封装起来后，对数据的访问只能通过已定义的接口进行。

（1）属性的封装。例：可以通过权限修饰符private来限制类，对它的属性进行隐藏，这样只能在类的内部访问访问它的属性。

public class Person {
    private String name;//修饰符 数据类型 变量名；
    private int age;//修饰符 数据类型 变量名；
    private float weight;//修饰符 数据类型 变量名；

在Person这个类中，对它的成员变量“name”、“age”、“weight”进行封装，用private来修饰他们。

（2）方法的封装。

private void speak(){
    System.out.println("这是封装");
}
修饰符 返回值类型 方法名（参数）

与属性的封装相同，也是用private来修饰方法speak，这样只能在该类或它的子类调用方法speak。需要注意的是，要访问私有属性和方法，需要提供另外的方法来进行访问，如（getXxx和setXxx）。

2.继承性

继承是类与类之间的关系。继承增强了代码的复用性，提高了开发效率。

继承需要用到extends关键字。java中只允许单继承，即一个类只能有一个父类，子类可以继承父类的属性与方法，私有属性也会被继承但一般无法访问。

public void Man extends Person{
    System.out.println("这是继承");
}
类名1 extends 类名2

子类Man继承于父类Person。

3.多态性

多态是指把子类型的对象主观的看作其父类型的对象，那么父类就可以是很多种类型。编译时类型指被看作的类型，是主观认定的。运行时类型是实际的对象实例的类型，是客观的。

多态的特性：对象实例确定后则不可改变；只能调用编译时类型所定义的方法；运行时会根据运行时类型去调用对应类型中定义的方法。

4.2 类和对象

在面向对象的概念当中，将具有相同属性和相同行为的一组对象称为类（class）。类是用于组合各个对象所共有的操作和属性的一种机制。类的具体化就是对象，即对象就是类的实例化。如：性别是一个类，男性和女性就是性别这一类的对象；男性是一个类，成年男性和和未成年男性就是男性这一类的对象。

4.2.1 什么是类

类是一种抽象的数据类型。类的声明格式如下：

标识符 class 类名
{
    类的成员变量
    类的方法
}

例：

public class Person {
    private String name;//修饰符 数据类型 变量名；
    private int age;//修饰符 数据类型 变量名；
    private float weight;//修饰符 数据类型 变量名；

private void speak(){
    String a = "字符串";
    System.out.println(a);
}
//修饰符 返回值类型 方法名（参数）

在该类中，组成元素为：标识符（修饰符）public 类名 Person

标识符 private 数据类型 String 变量名 name

标识符 private 数据类型 int 变量名 age

标识符 private 数据类型 float 变量名 weight

标识符 private 返回值类型 void 方法名 speak

其中变量有三种类型：

局部变量。是在方法、构造方法或者语法快中定义的变量。如String a = "字符串"。

成员变量。是定义在类中、方法体外的变量。如String name;int age;/float weight;

类变量。可以声明在类中、方法体之外，但必须为static类型。

4.2.2 类的方法

方法定义在类中，它和类的成员属性一起构成一个完成的类。要素为：方法名、返回值类型、参数列表、方法体。

修饰符 返回值类型 方法名（参数列表）
{
    方法体
    return 返回值;
}

方法包括一个方法头和一个方法体。方法头包括修饰符、返回值类型、方法名和参数列表。

修饰符：定义了该方法的访问类型。

返回值类型：指定了方法返回的数据类型。可以是任何有效的数据类型，如果没有返回值，则用void。返回值类型应和方法头中定义的返回值类型相同·。

方法名称：遵循java标识符命名规范，通常用英文动词开头。

参数列表：由类型、标识符组成，每个参数之间用逗号隔开。方法可以没有参数，但是方法名后的括号不能省略。

方法体：指{ }中的内容。

4.2.3 构造方法

java在创建对象时，允许对象初始化，初始化是由构造方法来完成。

构造方法的名称必须和类的名称完全相同。

构造方法不返回任何数据，也不需要用void关键字声明。

构造方法的作用是创建对象并初始化成员变量。

在创建对象时，系统会自动调用类的构造方法。

构造方法一般用public关键字声明。

每个类至少有一个构造方法。如果不定义构造方法，java将提供一个默认不带参数且方法体为空的构造方法。

构造方法可以重载。

public class Snake {
    String Type;
    String color;
    public Snake(String Type, String color){ 定义构造方法，有两个参数
        this.Type = "Viper";
        this.color = "Black";
    }

    public Snake() { 为了避免参数不足两个而报错，我们定义一个无参数的同名构造方法
        this.Type = "";
        this.color = "";
    }
    public void speak(){
        System.out.print(Type + color);
    }
}

方法能返回返回任何类型的值或者无返回值（void）；构造方法没有返回值，也不需要void。

4.2.4 认识对象

创建对象的步骤：

声明：声明一个对象，包括对象名和对象类型。
实例化：使用关键字new来创建一个对象。
初始化：使用new创建对象时，会调用构造方法初始化对象。

格式如下：

类名 对象名 = new 类名（）；
例，声明一个对象：
Person p1；
将它实例化：
p1 = new Person（）；
可以连起来写：
Person p1 = new Person（）；

访问成员变量或者方法：

对象名.属性名
对象名.方法名（）

访问Person的成员变量（属性）和方法：
p1.name；
p1.age；
p1.speak（）；

给变量赋值：
p1.name = "张三";
p1.age = "18";

4.3 对象值的传递

4.3.1值传递

实际参数把它的值对应的形式参数，方法执行中形式参数的值不影响实际参数的值。传递值的数据类型主要是基本数据类型。

public class Test2 {
    public static void change(int i, int j){
        int temp = i;
        i = j;
        j = temp;
    }

    public static void main(String[] args) {
        int a = 2;
        int b = 3;
        change(a ,b);
        System.out.println(a);
        System.out.println(b);

    }
}

过程：将 i 的值赋给temp，再将 j 的值赋给 i，再将temp的值赋给 j。我们将 a 和 b 作为change的参数，但最后输出的结果 a 和 b 的值没有改变，说明值的传递不会改变原值。

4.3.2 引用传递

引用传递也称为地址传递。方法调用时，实际参数的引用（地址）被传递给方法中对应的形式参数。在方法执行中，对形式参数的操作也就是对实际参数的操作，形式参数值的改变会影响实际参数值。

传递地址值的数据类型可以为除了String以外的所有复合数据类型。

public class Test3 {
    public static void change(Farmer f1){
        f1 = new Farmer("male" ,1,1);
        f1.attack_point += 1;

    }

    public static void main(String[] args) {
        Farmer f1 = new Farmer("male" ,0 ,0);
        change(f1);
        System.out.println(f1.attack_point);
    }
}

change方法中的 f1 = new Farmer("male" ,1,1); 构造了一个新的对象，已经不是主函数main 中的 f1 了。

4.4 作用于修饰符

4.4.1 访问修饰符

访问修饰符有private、protected、public。

1.私有的访问修饰符private

被声明为private的方法，变量和构造方法只能被所属类访问，并且类和接口不能声明为private。

声明为私有访问类型的变量只能通过类中的公共方法被外部类访问。


public class PrivateTest{
    private String name; 私有的成员变量
    public String getName(){ 私有成员变量的get 方法
        return name;
    }
    public void setName (String name) { 私有成员变量的 set 方法
        this.name = name;
    }
    public static void main(String[] args){
    privateTest p = new PrivateTest(); 创建类的对象
    p.setName("private访问修饰符")； 调用对象的set方法，为成员变量赋值
    System.out.println("name="+ p.getName()
    }; 打印成员变量name的值
}

2.无访问修饰符（默认修饰符）

不使用访问修饰符声明的变量和方法，可以被这个类本身或者与类在同一个包内的其他类访问。

3.受保护的访问修饰符protected

protected修饰符不能修饰类和接口，方法和成员变量能够被声明为protected。但是接口的成员变量和成员方法不能声明为protected。只有同一个包中类才可以访问它。

package Test;

    public class Weapon {
    protected String weapon;

    protected Weapon(String weapon){
        this.weapon = weapon;

    }
    protected Weapon(){
        this.weapon = "";

    }
    protected void fire(){
        System.out.print(" use " + weapon + " make a attack to ");
    }
}

package Test;

public class Test {
    public static void main(String[] args) {
        Weapon w1 = new Weapon();
        w1.weapon = "pistol";
        w1.fire();
    }
}