Java面向对象【详解一】 —— 类和对象 + 封装 + 继承 + 代码块 + 构造方法 + 关键字（static、this、super）

龙洋静

已于 2022-07-31 15:29:04 修改

阅读量793

点赞数 5

分类专栏： Java 文章标签： java

于 2022-07-30 14:48:16 首次发布

本文链接：https://blog.csdn.net/LYJbao/article/details/126026687

版权

Java 专栏收录该内容

36 篇文章 2 订阅

订阅专栏

一、提问：

1、什么是类?

类，就是一个自定义类型（好比C语言当中的结构体）

类，就是一类对象的统称

2、什么是对象?

实体

—— 把类看作是图纸，那对象就是就是根据图纸所建造出来的实实在在的房子。并且呢，根据一个图纸，可以建造出来很多房子，所以一个类，可以产生多个对象。

3、什么是面向对象?

         面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。

         用面向对象方式来进行处理问题时，就不会关注过程，通过对象之间的交互来完成的。

        面向对象：找对象——>创建对象——>使用对象

二、类和类的实例化

类在java中属于引用类型，java使用关键字class来声明类

创建一个类的语法：

class class_name {

field;//成员变量——>字段/属性

method;// 成员方法——>行为

}

举例：

1、定义一个类

class Person {
    //成员变量
    String name;//名字
    String sex;//性别

    int age;//年龄

    //成员方法——>行为
    public void eat() {
        System.out.println("eat!");
    }
    public void sleep() {
        System.out.println("sleep!");
    }
}

注意：

1、定义成员变量时，它是在方法的外面，类的里面，如果在方法里面定义了一个变量，他是

一个局部变量，存放在栈上。

2、实例成员变量的位置是在对象里面的，而静态成员变量（static修饰的变量）不在对象里面。

2、实例化一个对象

new 关键字用于创建一个对象的实例：

Person person1=new Person();

创建的局部变量person是在栈区的，我们new出来的Person是在堆区上的，看图：

3、访问对象当中的成员变量

使用（ . ）操作符来访问对象中的属性和方法，

引用 . 实例成员变量

如：

System.out.println(person1.name);
System.out.println(person1.sex);
System.out.println(person1.age);

注意：

在没有初始化时，打印成员变量，其默认值是其对应的0值，简单类型就是0(int--->0,float----->0.0,double--->0,char--->'\u0000' ,boolean-->false），引用类型(String,Array,及自定制类）就是null（null为“空引用”，表示不引用任何对象，如果对null进行 . 操作就会引发异常）

访问静态成员：

类名 . 静态成员变量

class Dog {
    static int age;
}
class Test1 {
    public static void main(String[] args) {
        System.out.println(Dog.age);
    }
}

输出：0

4、访问对象当中的成员方法

访问对象当中的成员方法

用 . 操作符，同访问实例成员变量类似

  Person person1=new Person();
  person1.eat();
  person1.sleep();

访问静态成员变量，同访问静态成员变量类似：

class Dog {
    static void func() {
        System.out.println("func()");
    }
}
class Test1 {
    public static void main(String[] args) {
        Dog.func();
    }
}

实例化成员与静态成员的区别到底是什么呢？

实例化成员，你创建几个对象，他在堆区上就会有几个成员，而静态成员，不管你创建多少个对象，他都是只有一份

三、关键字1——static

1、static修饰成员变量

static 修饰的成员变量，称为静态成员变量

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

【静态成员变量特性】

1. 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中

2. 静态成员变量一般使用类名访问

3. 类变量存储在方法区当中

4. 生命周期伴随类的一生 ( 即：随类的加载而创建，随类的卸载而销毁 )

class Test {
    public int a;
    public static int b;
}
class Test1 {
    public static void main(String[] args) {
        Test t1=new Test();
        t1.a++;
        Test.b++;

        System.out.println(t1.a);
        System.out.println(Test.b);

        Test t2=new Test();
        t2.a++;
        Test.b++;
        System.out.println(t2.a);
        System.out.println(Test.b);

    }
}

正确输出： 1 1 1 2

初始值默认是0，所以加1后为1，为什么b为2呢？因为他是一个静态成员变量，只存在一份，所以只要有人动了他，它的值就会发生变化

2、static修饰成员方法

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

一般是通过静态方法来访问的。静态方法内部，不能够访问非静态的数据成员

【 静态方法特性 】

1. 不属于某个具体的对象，是类方法

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

3. 不能在静态方法中访问任何非静态成员变量（我们在接触类之前，自定义一个方法时，看

下面的代码，会加上一个static 否则会报错，为什么？因为main方法是static）

4. 静态方法中不能调用任何非静态方法，因为非静态方法有 this 参数，在静态方法中调用时

候无法传递this 引用（关于this继续往下看呀）

5. 静态方法无法重写，不能用来实现多态

 public static void func() {
        System.out.println("func");
    }
    public static void main(String[] args) {
        func();
}

四、封装

封装：

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

进行封装：

1、将属性私有化，被private修饰，加入权限修饰符

private——>私有——限定只能在类当中访问

2、提供public修饰的方法让别人来访问使用

3、即使外界可以通过方法来访问属性了，但是也不能随意访问，因为可以在方法中加入限制条件。

4、设置getter、setter方法，给别人提供访问的路径，idea快捷键：alt+insert键快速生成

封装的作用：提高代码的安全性

如果没有特殊要求，类中的属性都设为私有的，体现封装

代码：

class People {
    private String Name;
    private int Age;

    //提供公共的接口

    //打印时调用的
    //姓名：
    public String getName() {
        return Name;
    }
    //年龄：
    public int getAge() {
        return Age;
    }

    //传参来修改他的数据
    //姓名
    public void setName(String name) {
        Name = name;
    }
    //年龄
    public void setAge(int age) {
        Age=age;
    }

}
public class Test2 {
    public static void main(String[] args) {
        People p=new People();
        p.setName("小明");
        String name=p.getName();
        System.out.println(name);
        p.setAge(18);
        int age=p.getAge();
        System.out.println(age);
    }
}

注意一点：

在修改参数set的接口中，形参与类中的成员变量不能同名，因为如果同名了，局部变量优先（就近原则），他就是自己给自己赋值了

如果一定要写成同名，需要使用this

this表示当前对象的引用

class Student {
    private int Age;

    //接口：
    public int getAge() {
        return Age;
    }
    public void setAge(int Age) {
        this.Age=Age;
    }
}
public class Test2 {
    public static void main(String[] args) {
        Student s=new Student();
        s.setAge(18);
        System.out.println(s.getAge());
    }
}

五、关键字2——this

this 引用指向当前对象 ( 成员方法运行时调用该成员方法的对象 ) ，在成员方法中所有成员变量的操

作，都是通过该 引用去访问 。

只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

this的功能：

1、this()：调用自己的构造方法（构造方法重载时，一个构造方法内部，可以使用this()调用

其他的构造方法，只能在构造方法里面写，并且只能调用一次，因为this()只能写在第一

行）。

2、this.data：调用当前对象的属性

3、this.func()：调用当前对象的方法

一定要习惯使用this

六、构造方法

new的过程是：

1、为对象分配内存空间

2、调用对象的构造方法

语法规则：

1、构造方法的名字必须与类名相同

2、构造方法不能由编程人员调用，而要系统调用。

3、

        （1、当你没有提供构造方法时，一个类会默认有一个构造方法，是空参的。

          eg. public Person(){ }

        （2、当你提供了构造方法，编译器就不会自动生成一个构造方法了

4、没有具体的返回值（不能由return 带回数据）

构造方法格式：

访问权限修饰符号方法名（参数列表）{

//方法体…

}

注：构造方法可以重载

构造方法的作用：实例化一个对象

构造方法和一般方法的区别？
（1）构造方法在对象创建的时候就生成了，只执行一次。（创建时间点、调用次数）
（2）一般方法是在对象创建后，需要使用时才被对象调用，并可以被多次调用

使用举例：

class Person {
    private String name;
    private int age;
    //构造方法1：
    public Person() {
        this("zhangsan",18);
        System.out.println("Person的构造方法1");
    }
    //构造方法2：
    public Person(String name ,int age) {
        this.name=name;
        this.age=age;
        System.out.println("Person的另一个构造方法");
    }

}
public class BuildingMethod {
    public static void main(String[] args) {
        Person p = new Person();
    }
}

输出：

七、代码块

1、实例代码块/构造代码块

2、静态代码块

3、本地代码块

看代码，里面注释仔细看：

class Person1 {
    private String name;
    private int age;
    //实例代码块
    {
        age=18;
        name="zhangsan1";
        System.out.println("实例代码块");
    }
    //静态代码块
    static  {
        //不能访问非静态的数据成员
        System.out.println("静态代码块");
    }
    public Person1() {
        System.out.println("构造方法");
    }
}
public class CodeBlock {
    public static void main(String[] args) {
        Person1 p=new Person1();
        System.out.println("----------------------");
        Person1 p1=new Person1();
    }
}

结果：

结论：静态的内容，只执行一次，并且是最早执行的

顺序：

1、静态代码块

2、实例代码块

3、构造方法

八、继承

1、概念：

继承 (inheritance) 机制：

是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性

的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设

计的层次结构，体现了由简单到复杂的认知过程。

继承其实就是类似于父子间的关系，可以借助父子关系去理解继承

2、继承的好处：

（1、共性的抽取，实现代码复用。

（2、子类可以在父类的基础上，增加其他的功能，使子类“青出于蓝而胜于蓝”

3、语法：

class 子类 extends 父类 {}

例子：

使用继承前：

父：

class Father {
    private int money;
    private String surname;//姓氏
    //接口：

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    public String getSurname() {
        return surname;
    }

    public void setSurname(String surname) {
        this.surname = surname;
    }
}

子：

class Son {
    
    private int age;

    private int money;
    private String surname;//姓氏

    //接口：

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    public String getSurname() {
        return surname;
    }

    public void setSurname(String surname) {
        this.surname = surname;
    }
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

我们会发现父类和子类的代码是高度相似，而我们以前所学却解决不了，因此要利用继承来解决：

使用继承：

//父类
class Father {
    private int money;
    private String surname;//姓氏
    //接口：

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    public String getSurname() {
        return surname;
    }

    public void setSurname(String surname) {
        this.surname = surname;
    }
}

//子类：
class Son extends Father {
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
public class Inherit {
    public static void main(String[] args) {
        Son s=new Son(); // 实例化的是子类
        s.setMoney(1000); // Father类定义
        s.setSurname("龙"); // Father类定义
        s.setAge(18);//Son类中特有的
        System.out.println("姓氏：" + s.getSurname() +".存款："+s.getMoney()+" .年龄："+s.getAge());
    }
}

输出：

注意一点：这个例子中，用钱举例是不恰当的，因为如果儿子把钱花了，老爸也没有了，但继承中，是子类将父类中的复制了一份，儿子即使把钱花了，但爸爸的钱还是在的

补充：父类也叫做基类 / 超类——子类也叫做派生类

内存中子类的存储：

4、继承的特点：

1、Java只支持单继承，不支持多继承（C++支持），但支持多层继承

单继承：大家可以理解为，儿子只能有一个爸爸，而爸爸可以有多个儿子

多层继承：爷爷——爸爸——儿子【爷爷是儿子的间接父类】

2、Java中所有的类都直接或者间接继承Object类

5、子类可以继承父类中哪些东西?

1、构造方法：子类无法继承父类中的构造方法

构造方法的名称是不同的，需要和类名一致

2、成员变量：无论是public 还是private修饰的成员变量，都可以被继承下来（继承和调用是不同的）

将私有的成员变量继承下来，是不可以直接被调用的，要利用 get,set 来帮助使用（如同我们上述举例中的）

3、成员方法：非私有的可以继承，私有的不能继承（private修饰）

九、关键字3——super

super

子类和父类中可能会存在相同名称的成员，如果要在子类方法中访问父类同名成员时，Java提供

了 super 关键字，该关键字主要作用：在子类方法中访问父 类的成员 。

super的功能：

1、super()：调用父类的构造方法

2、super.data：调用父类的属性

3、super.func()：调用父类的方法

简单使用举例：

//父类
class A {
    int a=5;
}
class B extends A{
    int a=1;
    public void func(int a) {
        System.out.println(a);
        System.out.println(this.a);
        System.out.println(super.a);
    }
}
public class Super {
    public static void main(String[] args) {
        B b=new B();
        b.func(10);
    }
}

根据就近原则，以及this super的使用，思考输出结果。

正确结果为：

好了，今天先到这里呀！多态以及接口我们下期见！！！

龙洋静

关注

5
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
1
评论
Java面向对象【详解一】 —— 类和对象 + 封装 + 继承 + 代码块 + 构造方法 + 关键字（static、this、super）

一、提问：1、什么是类?2、什么是对象?3、什么是面向对象?二、类和类的实例化1、定义一个类2、实例化一个对象3、访问对象当中的成员变量4、访问对象当中的成员方法三、关键字1——static1、static修饰成员变量2、static修饰成员方法四、封装五、关键字2——this六、构造方法七、代码块八、继承1、概念：2、继承的好处：3、语法：4、继承的特点：5、子类可以继承父类中哪些东西?九、关键字3——super...
复制链接

扫一扫