Java后端——面向对象（更新中。。。下一期多态）

已于 2024-07-30 10:42:19 修改
阅读量606 收藏 20
点赞数 22
分类专栏： Java后端 文章标签： java 开发语言
于 2024-07-19 16:17:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_81852311/article/details/140549673
版权

1.类和对象

1.2简单理解类

类的理解

        类是现实生活中一类具有共同属性和行为的事物的抽象

        类是对象的数据类型，类具有相同属性和行为的一组对象的集合

        简单理解：类就是对现实事物的一种描述

类的组成

        属性：指事物的特征，例如：手机事物（品牌、价格、尺寸）

        行为：指事物能执行的操作，例如：手机事物（打电话，发短信）

1.2类和对象的关系

类：类是指现实生活中一类具有相同属性和行为的事物的集合

对象：是能够看得到摸得着的真实的实实在在的实体

简单理解：类是对事物的一种描述，对象是具体存在的事物

1.3类的定义

类的组成是由属性和行为两部分组成

        属性：在类中通过成员变量来实现

        行为：在类中通过成员方法来实现

类的定义步骤：

①定义类

②编写类的成员变量

③编写类的成员方法

例如：

public class Student{
属性：姓名，年龄
String name;
int age;

行为：学习
public void study(){
    System.out.println("学习");
    }
}

1.4对象的创建和使用

对象的创建格式：

        类名 对象名 = new 类名();

调用成员格式：

        对象名 . 成员变量

        对象名 . 成员方法();

示例代码：

shili类
public class shili {
    String name;
    int age;

    public void Study(){
        System.out.println(name+age+"好好学习");
    }
}
Test类
public class Test {
    public static void main(String[] args) {
        shili sh = new shili();
        sh.age=19;
        sh.name="南镇";
        sh.Study();
    }
}

1.5案例——手机类的创建和使用

需求：首先定义一个手机类，然后定义一个手机测试类，在手机测试类中通过对象完成成员变量和成员方法的使用

成员变量：品牌，价格

成员方法：打电话，发短信

示例代码：

Phone类
public class Phone{
    //成员变量
    String brand;
    double price;
    //成员方法
    public void call(){
        System.out.println("南镇使用"+price+"元的"+brand+"手机打电话");
    }
    public void send(){
        System.out.println("南镇使用"+price+"元的"+brand+"手机发短信");
    }

}


Test类
public class Test{
    public static void main(String[] args) {
        Phone p = new Phone();
        p.price=3999.9;
        p.brand="小米";
        p.call();
        p.send();
    }
}

2.对象内存图

2.1单个对象内存图

2.2多个对象内存图

总结 ：多个对象在堆内存中，都有不同的内存划分，成员变量存储在各自的内存区域中，成员方法多个对象共用的一份

2.3多个对象指向相同内存图

总结：当多个对象的引用指向同一个内存空间，只要有任何一个对象修改了内存中的数据，随后，无论使用哪个对象进行获取，都是修改后的数据

3.成员变量和局部变量

3.1成员变量和局部变量的区别

类中位置不同：成员变量在类中方法外，局部变量在方法声明上或者在方法里面

内存中位置不同：成员变量在堆内存里，而局部变量实在栈内存里

生命周期不同：成员变量生命周期随着对象消失而小时，而局部变量生命周期随着方法结束和小时

初始化值不同：成员变量有默认初始化值，局部变量没有初始化值，必须先定义赋值，之后才能调用

4.封装

4.1private关键字

概述：private是一个修饰符，可以用来修饰成员（成员变量、成员方法）

特点：被private修饰的成员，只能在本类中进行访问，针对private修饰的成员变量，如果需要被其他类调用，则需要提供  get（）和   set（）方法

示例代码：

Phone类
public class Phone{
    //成员变量
    private String brand;
    private double price;

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    //成员方法
    public void call(){
        System.out.println("南镇使用"+price+"元的"+brand+"手机打电话");
    }
    public void send(){
        System.out.println("南镇使用"+price+"元的"+brand+"手机发短信");
    }

}

Test类
public class Test{
    public static void main(String[] args) {
        Phone p = new Phone();
        p.setPrice(3999.8);
        p.setBrand("小米");
        p.call();
        p.send();
    }
}

4.2private关键字的使用

需求：

①、定义标准的学生类，要求name和age用private修饰

②、并提供set和get方法以及便于显示数据的show方法

③测试类中创建对象并使用，最终控制台输出 林青霞，30

示例代码：

student类
public class Student {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

    public void show(){
        System.out.println(name+","+age);
    }
}

Test类
public class Test{
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("南镇");
        s1.setAge(20);
        s1.show();
    }
}

 结果：

4.3this关键字

概述：this修饰的变量用于代指成员变量，其主要作用就是区分局部变量和成员变量重名问题

        方法的形参如果与成员变量重名，不带this修饰的变量指的是形参，而不是成员变量

        方法的形参没有与成员变量重名，不带this修饰的变量指的是成员变量

代码实现：

public class Student {
    private String name;
    private int age;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}

4.4this内存原理

注意：this代表当前调用方法的引用，哪个对象调用的方法，this就代表哪个对象

4.5封装思想

1、封装的概述

        是面向对象的三大特征之一（封装，多态、继承）

        是面向对象编程语言对客观世界的模拟，客观世界里的成员变量都是隐藏在对象内部的，外            界是无法直接操作的

2、封装的原则

        将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过类提供的方法来实现            访问

3、封装的好处

        通过方法来控制成员变量的操作，提高了代码的安全性

        把代码用方法进行封装，提高了代码的复用性

        

5.构造方法

5.1构造方法的格式和执行时机

格式注意：

        方法名与类名相同，大小写要一致

        没有返回值类型，连void都没有

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

执行时机：

        创建对象的时候调用，创建一次对象，就要执行一次构造方法

        不能手动调用构造方法

示例代码：

class Student {
    private String name;
    private int age;

    //构造方法
    public Student() {
        System.out.println("无参构造方法");
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}
/*
    测试类
 */
public class LianXi {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        s.show();
    }
}

5.2构造方法的作用

用于给对象的数据初始化

public class Student {
    /*
        格式:

               1. 方法名需要跟类名相同, 大小写也要一致
               2. 没有返回值类型, 连void都没有
               3. 没有具体的返回值(不能由return带回具体的结果)
     */

    private String name;
    private int age;

    // 1. 如果一个类中没有编写任何构造方法, 系统将会提供一个默认的无参数构造方法
    public Student(){}

    // 2. 如果手动编写了构造方法, 系统就不会再提供默认的无参数构造方法了
    public Student(String name, int age){
        this.name = name;
        this.age = age;
        System.out.println("我是Student类的构造方法");
    }

    public void show(){
        System.out.println(name + "..." + age);
    }
}
public class TestStudent {
    public static void main(String[] args) {
        Student stu1 = new Student("张三",23);
        stu1.show();

        Student stu2 = new Student();
    }
}

5.3构造方法的注意事项

构造方法的创建：

如果没有构造方法，系统会给出一个默认的无参构造方法

如果定义了构造方法，那么系统不在给出默认的无参构造方法

推荐的使用方式：

无论是否使用，都手动写带参和无参的构造方法。

6.继承

6.1继承的实现

继承的概念

        继承是面向对象的三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法

        继承的格式

        继承通过extends来实现

        格式：class 子类 extends 父类   {  }

继承的好处

        继承可以让类与类之间产生关系，子类可以使用父类中的非私有成员

示例代码：

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();
    }
}
class Animal{
    public void eat(){
        System.out.println("动物吃食物");
    }
}
class Dog extends Animal{
    public void eat(){
        System.out.println("狗吃狗粮");
    }
}

结果：

 

 6.2继承的利弊

        继承好处：

        提高了代码的复用性和维护性

        继承弊端：

        增加了类与类之间的耦合性，当父类变化时候，子类也要变化，削弱了子类的独立性

        继承应用场景：

        需要考虑类与类之间是否存在is..a的关系，不能盲目使用继承

        is..a的关系：谁是谁的一种，例如：老师和学生是人的一种，那人就是父类，学生和老师

就是子类。

6.3.Java中继承的特点

Java中的继承特点

        Java中类仅支持单继承，不支持多继承

        Java中类支持多层继承

7.继承中的成员访问特点

7.1继承中的成员访问特点

在子类方法中访问一个变量，采用的是就近原则

        1、子类局部范围内查找

        2、子类范围内查找

        3、父类范围内查找

        4、如果都没有找到就报错

public class Test {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.showZi();
    }
}
class Fu{
    int a = 100;
    public void showFu(){
        System.out.println(a);
    }
}
class Zi extends Fu{
    int b = 200;
    public void showZi(){
        System.out.println(b);
    }
}

结果： 

7.2super

        this & super 关键字：

this：代表奔雷对象的引用

super：代表对父类对象的引用

        this & super的使用差别

成员变量：

this.成员变量    ——访问本类的成员变量

super.成员变量  ——访问父类的成员变量

成员方法：

this.成员方法    ——访问本类的成员方法

super.成员方法  ——访问父类的成员方法

7.3继承中构造方法的访问特点

注意：子类中所有的构造方法都会默认访问父类中的无参构造方法        

        子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化，原因在于，每一个子类构造方法的第一条语句默认都是：super()

问题：如果说父类没有无参构造方法，只有带参构造方法，该怎么办

1、通过使用super关键字去调用父类的带参构造方法

2、子类先通过this关键字调用本类的其他构造方法，然后本类的其他构造方法在通过super去手动调用带参构造方法

7.4继承中的成员方法的访问特点

1、子类范围内查找

2、父类范围内查找

3、如果没找到就编译报错

7.5. super内存图

对象在堆内存中，会单独存在一块区域负责存储父类的数据

7.6 方法的重写

1、方法重写的概念

        子类出现和父类一模一样的方法申明（方法名，参数均相同）

2、方法重写的场景

        子类需要父类的功能，但是子类有他自己内容的实现，这样不仅沿袭了父类的功能，有定义了自己的特有的内容

3、Override注解

        用来检测当前的方法是否符合重写规范

7.7.方法重写的注意事项

方法重写的注意事项

1、私有方法不能重写

2、静态方法不能重写

3、子类的权限要大于父类

7.8 .权限修饰符

8.抽象 

8.1抽象类的概述

        在Java中，没有方法体的方法我们称之为抽象方法，如果类中存在抽象方法，那么这个类就称之为抽象类

8.2 抽象类的特点

        抽象类和抽象方法必须有 abstract 关键字修饰

//抽象类的定义
public abstract class 类名 {}

//抽象方法的定义
public abstract void eat();

        抽象类不能被实例化

        抽象类没有构造方法

        抽象类中不一定有抽象方法，但是由抽象方法的类一定是抽象类

        抽象类的子类

                1、要么重写抽象类中所有的抽象方法

                2、要么子类也是个抽象类

8.3.抽象类的示例 

案例需求：

定义猫类(Cat)和狗类(Dog)

猫类成员方法：eat（猫吃鱼）drink（喝水…）

狗类成员方法：eat（狗吃肉）drink（喝水…）

实现步骤：

  1. 猫类和狗类中存在共性内容，应向上抽取出一个动物类（Animal）

  2. 父类Animal中，无法将 eat 方法具体实现描述清楚，所以定义为抽象方法

  3. 抽象方法需要存活在抽象类中，将Animal定义为抽象类

  4. 让 Cat 和 Dog 分别继承 Animal，重写eat方法

  5. 测试类中创建 Cat 和 Dog 对象，调用方法测试

代码实现：

public class Test {
    public static void main(String[] args) {
        Cat c = new Cat();
        Dog d = new Dog();
        c.eat();
        d.eat();
        c.drink();
        d.drink();
    }
}

abstract class Animal {
    abstract void eat();
    abstract void drink();
}
class Cat extends Animal {

    @Override
    void eat() {
        System.out.println("猫吃鱼");
    }

    @Override
    void drink() {
        System.out.println("猫喝水");
    }
}
class Dog extends Animal {

    @Override
    void eat() {
        System.out.println("狗吃肉");
    }

    @Override
    void drink() {
        System.out.println("狗喝水");
    }
}

结果： 

 8.4.final

final关键字的作用

        final表示最终的意思，可以修饰类，成员方法，成员变量

final修饰类，方法，成员变量的效果

        final修饰类：代表该类不能被继承（不能有子类），但是可以有父类

        final修饰方法：代表该方法不能被重写

        final修饰变量：代表该变量是常量不能再次修改赋值。

                                该变量如果是基本数据类型，就不能修改值

                                该变量如果是引用数据类型，则不能修改地址，但是里面内容可以该改变

9.代码块

9.1代码块的概述

在Java中，用  {  }  括起来的代码叫做代码块

9.2代码块的分类

局部代码块

        位置：方法中定义

        作用：限定变量的生命周期，提高内存利用率

        示例代码：

public class Test{
    public static void main(String[] args) {
        {
            System.out.println("这里是局部代码块");
        }
    }
}

        结果：

静态代码块

        位置：类中方法外

        特点：需要通过static关键字进行修饰，随着类的加载而加载，并只执行一次

        作用：在类加载的时候做一些初始化的操作

        示例代码：

public class Test {
    public static void main(String[] args) {
        Person person = new Person();
        Person person1 = new Person(19);
    }
}
class Person{
    String name;
    int age;

    static {
        int a = 10;
        System.out.println(a);
        System.out.println("我是静态代码块");
    }

    public Person(){
        System.out.println("空参数构造方法");
    }

    public Person(int a){
        System.out.println("带参数构造方法...........");
    }
}

        结果：

结构代码块

        位置：类中方法外

        特点：每次构造方法执行时，都会执行该代码块中的代码，并且在构造方法执行前就执行

        作用：将多个构造方法中相同的代码，抽取到构造代码块中，提高代码的复用率

        示例代码：

public class Test {
    public static void main(String[] args) {
        Person person = new Person();
        Person person1 = new Person(19);
    }
}
class Person{
    String name;
    int age;

    {
        System.out.println("好好学习");
    }

    public Person(){
        System.out.println("空参数构造方法");
    }

    public Person(int a){
        System.out.println("带参数构造方法...........");
    }
}

        结果：

10.接口

10.1接口的概述

        接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。

        Java中接口存在的意义就是用来定义规范和扩展功能

10.2接口的特点

        接口用关键字 interface 来修饰

        类实现接口用 implement 来实现

        接口不能被实例化

        接口的子类要么重写接口中所有抽象方法，要么子类也是抽象类

10.3接口的成员特点

成员特点

        成员变量

                只能是常量

                默认修饰符是public static final

        构造方法

                没有构造方法，因为接口是扩展功能的

        成员方法

                只能是抽象方法

                默认修饰符是public abstract

                关于接口中的方法，JDK8和JDK9中有一些新特性 在第十一章讲述

10.4类与接口的关系

类与类的关系

        继承关系，只能单继承，可以多层继承

类与接口的关系

        实现关系，可以单实现，可以多实现，也可以在继承一个类的同时实现多个接口

接口与接口的关系

        继承关系，可以单继承，也可以多继承

​​​​​​​11.接口组成

11.1接口组成：

        常量

        抽象方法

        默认方法

        静态方法

        私有方法

11.2.接口中的默认方法

格式

        public defult 返回值类型 方法名 （参数）{ }

作用

        解决接口升级问题

范例

public default void show3() { 
}

注意事项

        默认方法不是抽象方法，所以不强制被重写。但是可以被重写，重写的时候去掉default关键字

        public可以省略，default不能省略

        如果实现了多个接口，多个接口中存在相同的方法声明，子类就必须对该方法进行重写

11.3.接口中的静态方法

格式

        public static 返回值类型 方法名(参数列表) { }

范例

public static void show() {
}

注意事项

        静态方法只能通过接口名调用，不能通过实现类名或者对象名调用

        public可以省略，static不能省略

11.4.接口中的私有方法

私有方法产生的原因：

        Java 9中新增了带方法体的私有方法，这其实在Java 8中就埋下了伏笔：Java 8允许在接口中定义带方法体的默认方法和静态方法。这样可能就会引发一个问题：当两个默认方法或者静态方法中包含一段相同的代码实现时，程序必然考虑将这段实现代码抽取成一个共性方法，而这个共性方法是不需要让别人使用的，因此用私有给隐藏起来，这就是Java 9增加私有方法的必然性

定义格式

        格式1

                private 返回值类型 方法名(参数列表) { }

        范例1

private void show() {  
}

        格式2

                 private static 返回值类型 方法名(参数列表) { }

        范例2

private static void method() {  
}

 注意事项：

        默认方法可以调用私有的静态方法和非静态方法

        静态方法只能调用私有的静态方法

南镇132
关注
  • 22
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值