Java基础之面向对象（一）

小龙人000

已于 2023-02-12 11:11:19 修改

阅读量64

点赞数

分类专栏： Java 面向对象文章标签： java 面试

于 2023-02-12 10:58:31 首次发布

本文链接：https://blog.csdn.net/qq_53350943/article/details/128982604

版权

Java 同时被 2 个专栏收录

18 篇文章 1 订阅

订阅专栏

面向对象

8 篇文章 0 订阅

订阅专栏

1.Java语言框架

2. 对比面向过程与面向对象

面向过程和面向对象都是编写应用程序的一种方法。

面向过程是一种以过程（方法）为最小颗粒度的编程语言。一个方法一定声明完成，这个方法的功能就不能改变了。

面向对象是一种以过程中使用的对象为最小颗粒度的编程语言。一个方法声明完成，会根据使用的对象的不同，而改变这个方法的功能。

3 类和对象（语法）

3.1 关系

类和对象之间的关系。必须是从现实世界向软件世界转换的过程。

3.2 创建类（语法）

类Class是一个特殊的数据类型。与int,String本质是一样的。

类中有属性和方法。 例如：学员，手机这些数据类型。

属性：就是变量。

方法：就是我们之前编写的方法。 public static void print(int i);

创建的基本语法：class就是类的关键字。

public class 类名{

}

public class A{

}

3.3 创建对象（语法）

类是一种特殊的数据类型。使用这个类型创建的变量也称为叫对象。

所以使用类创建一个对象时，需要使用new关键字进行实例化。

对象就可以通过打点的方式，调用类型中的属性和方法。

对象名.属性;

对象名.方法();

变量的使用规则：

声明

初始化

使用

int i;

A a;

i = 10;

a = new A();

sout(i);

a.属性=值;

sout(a.属性);

a.方法();

int x = a.方法();

public class A {
    int i = 10;
    public void print(){
        System.out.println("这是A类中的一个叫print方法");
    }
}

public class Test01 {
    public static void main(String[] args) {
        //使用A类创建对象a
        A a = new A();
        a.i = 40;
        System.out.println(a.i);
        a.print();
    }
}

3.4 专有名词

A a = new A();

a 我们叫引用。

new A(); new是实例化，实例化：在内存中创建实例空间的过程。

实例：就是我们内存中开辟的空间。

3.5 对象的内存结构

3.6 属性（语法）

属性：一般都是指在类中声明的变量，称为成员变量，也为成员属性。

针对成员属性，我们也叫实例属性。

成员属性：就是在类中声明的变量。

成员属性的作用域： 是受访问修饰符影响的。属性一般使用private。

private 表示私有。表示属性只在声明的这个类中可以使用。

3.7 方法（语法）

方法：成员方法，实例方法。在类中声明的方法。

成员方法的作用域：方法一般使用public。

public 表示公有。任意位置都可以使用。

成员方法可以用来操作成员属性。

实例属性和实例方法是属于实例的，每一个实例都有自己的实例属性和实例方法。

public class A {
    private int age = 10;//成员属性。私有的。可以在本类的任意位置使用。
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

//创建一个测试类

A a = new A();
a.setAge(24);
System.out.println(a.getAge());

3.8 JavaBean的规范

一个类如果按JavaBean规范编写，应该具备如下三个要求：

① 默认构造方法

② 私有属性

③ 公有set/get方法

set和get方法的命名格式规范：set和get做前缀，将属性名的首字母大写拼接。

3.9 this关键字

this是我们Java代码中的一个关键字。

this是在实例内部一个指向自身实例的引用。

我们使用this可以指定本类中的属性和方法。

4 类和对象（软件设计）

4.1 类是怎么来的？

类是对现实世界中具有相同属性和相同方法的大量对象的抽象。抽取相同的属性和方法。

抽象将得到属性和方法，再使用{ }封装起来。起个名，用个class关键字。

例如：我们做一个学员管理系统。对现实世界中大量的学员对象，进行抽象，抽属性和方法。

类是模板。

public class Stu {
    //有学号
    private int sid;
    //有姓名
    private String sname;
    //有睡觉的方法
    public void sleep(int hours){
        System.out.println(this.sname + "晚上休息了 "+hours+" 小时！");
    }

4.2 对象

类是模板，对象是具体的事物。对象是对客观事物的抽象，类是对对象的抽象。类是抽象的，

不占内存，对象是具体的，占用内存。对象是类的实例，类是对象的模板。对象通过new

classname产生的，用来调用类的方法和类的构造方法。

4.3 练习：编写如下的类

1. 编写汽车类

public class Car {
    //品牌
    private String type;
    //价格
    private int price;
    //跑
    public void run(int juli){
        System.out.println(this.type+"加满油能跑"+juli+"公里");
    }

2. 编写狗类

public class Dog {
//    编号
    private int id;
//    品种
    private String type;
//    年龄
    private int age;
//    性别
    private String gender;

    public void sleep(){
        System.out.println("狗会睡觉");
    }
    public void eat(){
        System.out.println("狗吃骨头");
    }
    public void call(){
        System.out.println("汪汪汪");
    }

5 构造方法

构造方法也是一个方法。是类中一个特殊的方法。

5.1 什么是构造方法

一个与类名同名的，并没有返回类型描述的方法。叫构造方法。

public class Stu {
    //构造方法
    public Stu(){
        System.out.println("构造方法！");
    }

5.2 构造方法的分类

构造方法有如下几种分类:

① 默认（无参）构造方法：一个没有参数的构造方法。

隐式构造方法：当一个类没有编写构造方法时，系统会自动为这个提供一个默认构造方法。

② 参数化（有参）构造方法：有参数的构造方法。

每一个类都有一个自己的构造方法。

5.3 构造方法的作用

构造方法是在对象被实例化时调用的方法。

在创建实例的过程中一定要调用构造方法来创建我们的对象。

构造方法不用我们指定。系统会根据new关键字后面的类的格式来调用对应的构造方法。

Stu s1 = new Stu();//new关键字时一定要调用构造方法。

系统会按Stu()来调用对应的构造方法。

构造方法的作用是在实例化时为类的属性进行初始化操作。

例：Stu 和Birthday 类的构造方法使用。

public class Stu {
    private int sid;
    private String sname;
    private Birthday birthday ;//被构造方法初始化的属性
    //构造方法
    public Stu(){
        System.out.println("构造方法！");
        birthday=new Birthday();
    }
    //有参构造
    public Stu(int sid, String sname,int year, int month, int day){
        this.sid = sid;
        this.sname = sname;
        birthday = new Birthday(year,month,day);
    }
    //Fn+Alt+Ins键
      //set&get
    @Override
    public String toString() {
        return "Stu{" +
                "sid=" + sid +
                ", sname='" + sname + '\'' +
                ", birthday=" + birthday +
                '}';
    }
}

public class Birthday {
    private int year;
    private int month;
    private int day;
    public Birthday() {
    }
    public Birthday(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
   }
    //set&get
    @Override
    public String toString() {
        return "Birthday{" +
                "year=" + year +
                ", month=" + month +
                ", day=" + day +
                '}';
    }
}

编写测试类：

public class TestStu {
    public static void main(String[] args) {
        Birthday birthday;
        birthday=new Birthday();
        birthday.setYear(2001);
        birthday.setMonth(4);
        birthday.setDay(20);
        System.out.println(birthday);

        Stu s=new Stu();
        s.setSname("嘎嘎嘎");
        s.getBirthday().setDay(20);
        s.getBirthday().setMonth(4);
        s.getBirthday().setYear(2001);
        s.setSid(55);
        System.out.println(s);
    }
}

6 对象创建的过程（扩展）

Stu s = new Stu(); //一个对象创建的完整过程包含二个部分 类加载 和 对象创建。

对象创建过程的步骤：实例化-初始化-引用赋值

① 实例化：内存中开辟实例（Stu），并为每一个属性赋默认值。

② 初始化：调用相应的构造方法（Stu()），来完成对属性的初始化。

③ 引用赋值：将实例的引用赋值给引用（s）。

7 任务：定义一个长方形的类

① 定义一个长方形的类。在这个类中有二个属性长和宽；

② 定义一个计算长方形周长的方法；

③ 定义一个计算长方形面积的方法。

public class React {
    private int chang;
    private int kuan;

    public void zc(){
        System.out.println("周长："+(chang+kuan)*2);
    }
    public void mj(){
        System.out.println("面积："+(kuan*chang));
    }
    public React(int chang, int kuan) {
        this.chang = chang;
        this.kuan = kuan;
    }
   //set&get
   //toString
}