Java基础疑点解析 1、对面向对象思想的理解 2、封装与继承

最新推荐文章于 2022-07-10 14:58:28 发布

乞力马扎罗的红叶

最新推荐文章于 2022-07-10 14:58:28 发布

阅读量93

点赞数

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

本文链接：https://blog.csdn.net/qq_44403157/article/details/117171960

版权

Java基础专栏收录该内容

13 篇文章 0 订阅

订阅专栏

1、对面向对象思想的理解
1.1 类和对象的理解
在这里插入图片描述
1.2 类的定义

/*
    类的定义

    类的定义步骤：
        定义类
        编写类的成员变量
        编写类的成员方法

    手机类：
        类名：
        手机(Phone)

        成员变量：
        品牌(brand)
        价格(price)

        成员方法：
        打电话(call)
        发短信(sendMessage)
 */
public class Phone {
    //成员变量
    String brand;
    int price;

    //成员方法
    public void call() {
        System.out.println("打电话");
    }

    public void sendMessage() {
        System.out.println("发短信");
    }
}

1.3、对象的使用
创建对象的格式：
类名对象名 = new 类名();
调用成员的格式：
对象名.成员变量
对象名.成员方法();

public class PhoneDemo {
    public static void main(String[] args) {
        //创建对象
        Phone p = new Phone();

        //使用成员变量
        System.out.println(p.brand);
        System.out.println(p.price);

        p.brand = "小米";
        p.price = 2999;

        System.out.println(p.brand);
        System.out.println(p.price);

        //使用成员方法
        p.call();
        p.sendMessage();
    }
}

1.4、对象内存图
单个对象的内存图
在这里插入图片描述

多个对象内存图

总结：
1、多个对象在堆内存中，都有不同的内存划分，成员变量存储在各自的内存区域中，成员方法多个对象共用的一份。
2.当多个对象的引用指向同一个空间(变量所记录的地址值是一样的)，只要有任何一个对象修改了内存中的数据，随后，无论使用哪一个对象从内存中获取数据，都是修改后的数据。

1.5、对面向对象思想的理解
首先，谈谈“面向过程”vs“面向对象”

我觉得这两者是思考角度的差异，面向过程更多是以“执行者”的角度来思考问题，而面向对象更多是以“组织者”的角度来思考问题，举个例子，比如我要产生一个0-10之间的随机数，如果以“面向过程”的思维，那我更多是关注如何去设计一个算法，然后保证比较均衡产生0-10的随机数，而面向对象的思维会更多关注，我找谁来帮我们做这件事，比如Random类，调用其中提供的方法即可。

所以，面向对象的思维更多的是考虑如何去选择合适的工具，然后组织到一起干一件事。

好比一个导演，要拍一场电影，那么首先要有男猪脚和女猪脚，然后还有其他等等，最后把这些资源组织起来，拍成一场电影。

再说回我们的程序世界，这个组织者的思维无处不在，比如，我们要开发项目，以三层架构的模式来开发，那么这个时候，我们不需要重复造轮子，只需要选择市面上主流的框架即可，比如SpringMVC，Spring，MyBatis，这些都是各层的主流框架。

2、封装与继承
2.1封装
封装概述
是面向对象三大特征之一（封装，继承，多态）
是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的
封装原则
将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
成员变量private，提供对应的getXxx()/setXxx()方法
封装好处
通过方法来控制成员变量的操作，提高了代码的安全性
把代码用方法进行封装，提高了代码的复用性
private关键字
private是一个修饰符，可以用来修饰成员（成员变量，成员方法）
被private修饰的成员，只能在本类进行访问，针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作
提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰
提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰
private的使用

/*
    学生类
 */
public class Student {
    //成员变量
    private String name;
    private int age;

    //get/set方法
    public void setName(String n) {
        name = n;
    }

    public String getName() {
        return name;
    }

    public void setAge(int a) {
        age = a;
    }

    public int getAge() {
        return age;
    }

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

/*
    学生测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        //使用set方法给成员变量赋值
        s.setName("林青霞");
        s.setAge(30);
        s.show();
        //使用get方法获取成员变量的值
        System.out.println(s.getName() + "---" + s.getAge());
        System.out.println(s.getName() + "," + s.getAge());
    }
}

this关键字
this修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）
方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量


```java
/*
    学生类
 */
public class Student {
    private String name;
    private int age;

//    public void setName(String n) {
//        name = n;
//    }

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

    public String getName() {
        return name;
    }

//    public void setAge(int a) {
//        age = a;
//    }

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

    public int getAge() {
        return age;
    }

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

this内存原理
只要记住一句话：哪个对象调用类中的成员与方法，this就指代谁。
构造方法
构造方法是一种特殊的方法
作用：创建对象 Student stu = new Student();
格式：
public class 类名{
修饰符类名( 参数 ) {
}
}
功能：主要是完成对象数据的初始化

/*
    成员变量
        使用private修饰

    构造方法
        提供一个无参构造方法
        提供一个带多个参数的构造方法

    成员方法
        提供每一个成员变量对应的setXxx()/getXxx()
        提供一个显示对象信息的show()
 */
public class Student {
    //成员变量
    private String name;
    private int age;

    //构造方法
    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = 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);
    }
}

/*
    创建对象并为其成员变量赋值的两种方式
        1:无参构造方法创建对象后使用setXxx()赋值
        2:使用带参构造方法直接创建带有属性值的对象
*/
public class StudentDemo {
    public static void main(String[] args) {
        //无参构造方法创建对象后使用setXxx()赋值
        Student s1 = new Student();
        s1.setName("林青霞");
        s1.setAge(30);
        s1.show();

        //使用带参构造方法直接创建带有属性值的对象
        Student s2 = new Student("林青霞",30);
        s2.show();
    }
}

构造方法的注意事项
在这里插入图片描述
2.2、继承
继承的实现

public class Fu {
    public void show() {
        System.out.println("show方法被调用");
    }
}

public class Zi extends Fu {
    public void method() {
        System.out.println("method方法被调用");
    }
}

public class Demo {
    public static void main(String[] args) {
        //创建对象，调用方法
        Fu f = new Fu();
        f.show();

        Zi z = new Zi();
        z.method();
        z.show();
    }
}

继承的好处和弊端
继承好处
提高了代码的复用性(多个类相同的成员可以放到同一个类中) 提高了代码的维护性(如果方法的代码需要修改，修改一处即可)
继承弊端
继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性继承的应用场景：
使用继承，需要考虑类与类之间是否存在is…a的关系，不能盲目使用继承 is…a的关系：谁是谁的一种，例如：老师和学生是人的一种，那人就是父类，学生和老师就是子类
继承中变量的访问特点
在子类方法中访问一个变量，采用的是就近原则。

子类局部范围找
子类成员范围找
父类成员范围找
如果都没有就报错(不考虑父亲的父亲…)
super
super 关键字的用法和 this 关键字的用法相似
this：代表本类对象的引用
super：代表父类存储空间的标识(可以理解为父类对象引用)

继承中构造方法的访问特点
子类中所有的构造方法默认都会访问父类中无参的构造方法
为什么呢？
因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化
每一个子类构造方法的第一条语句默认都是：super()

如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢？
通过使用super关键字去显示的调用父类的带参构造方法
在父类中自己提供一个无参构造方法
推荐：自己给出无参构造方法
Java中继承的注意事项
Java中继承的注意事项
1. Java中类只支持单继承，不支持多继承
错误范例：class A extends B, C { }

2. Java中类支持多层继承

public class Granddad { 
	public void drink() { 
		System.out.println("爷爷爱喝酒"); 
	} 
}
public class Father extends Granddad { 
	public void smoke() { 
		System.out.println("爸爸爱抽烟"); 
	} 
}
public class Mother { 
	public void dance() { 
		System.out.println("妈妈爱跳舞"); 
	} 
}
public class Son extends Father { 
// 此时，Son类中就同时拥有drink方法以及smoke方法 
}

权限修饰符
在这里插入图片描述
对号表示能访问。

参考资料：
https://www.bilibili.com/video/BV18J411W7cE?from=search&seid=5732323626279645000
黑马程序员笔记

乞力马扎罗的红叶

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础疑点解析 1、对面向对象思想的理解 2、封装与继承

1、对面向对象思想的理解1.1 类和对象的理解1.2 类的定义/* 类的定义类的定义步骤：定义类编写类的成员变量编写类的成员方法手机类：类名：手机(Phone) 成员变量：品牌(brand) 价格(price) 成员方法：打电话(call) 发短信(sendMessage)
复制链接

扫一扫