Java基础篇之面向对象篇

最新推荐文章于 2023-10-06 16:01:41 发布

big coke

最新推荐文章于 2023-10-06 16:01:41 发布

阅读量408

点赞数

本文链接：https://blog.csdn.net/weixin_43657820/article/details/105119348

版权

面向对象：

面向对象思想概述：

当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了，这时就开始思索，能不能把这些步骤和功能在进行封装，封装时根据不同的功能，进行不同的封装，功能类似的用一个类封装在一起，这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。

面向对象思想：

面向对象是基于面向过程的一种编程思想。

面向过程：强调的是每一个功能的步骤

面向对象：强调的是对象，然后由对象去调用功能

面向对象的思想特点：

A：是一种符合我们思考习惯的思想

B：可以将复杂的事情简单化

C：让我们从执行者成为了指挥者

1.类与对象的关系：

引出：

我们是如何表示现实世界的事物的呢：

A：属性就是事物的描述信息

B：行为就是事物能够做什么

Java 语言最基本的组成单位是类

类：是一组相关的属性和行为的集合

对象：就是该类事物的具体体现

举例：

类：学生

对象：张三

类如何与事物进行对应的呢？

类：

成员变量

成员方法

成员变量：和我们学过的变量定义是一样的，但有两个小区别

位置不同：类中，方法外

初始化值：成员变量不需要给初始化值也可以使用，因为它有默认值

成员方法：和我们学过的方法的定义是一样的，有一个小区别

去掉了修饰符中的static关键字

需求：定义一个学生类：

学生事物：

属性：姓名，年龄...

行为：学习，吃饭...

学生类：

成员变量：姓名，年龄...

成员方法：学习，吃饭...

public class Student {
String name;
int age;
public void study(){
    System.out.println("好好学习，天天向上");
}
public void eat(){
    System.out.println("学习累了要 吃饭");
}
}

学生类的使用：

类的使用：

使用一个类，其实就是使用该类的成员。（成员变量和成员方法）

而我们要使用一个类的成员，就必须先拥有该类的对象

如何创建对象：

格式：

类名对象名 = new 类名（）；

对象如何访问成员：

成员变量：

对象名.成员变量

成员方法：

对象名.成员方法（...）

public class Student_Test {
    public static void main(String[] args) {
        Student s = new Student();
        System.out.println("s:"+s);//输出s的地址值
        System.out.println("name:"+s.name);
        System.out.println("age:"+s.age);
        System.out.println("------------");
        //给成员变量赋值
        s.name = "林青霞";
        s.age = 30;
        //再次调用成员变量
        System.out.println("姓名："+s.name);
        System.out.println("年龄："+s.age);
        System.out.println("-------------");
        //调用成员方法
        s.study();
        s.eat();
    }
}

输出结果：

s:day_6.Student@7530d0a
name:null
age:0
------------
姓名：林青霞
年龄：30
-------------
好好学习，天天向上
学习累了要吃饭

练习2：手机的定义与使用：

手机类：

成员变量：品牌，价格，颜色...

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

public class phone {
String brand;
String color;
int price;
public void call(String name){
    System.out.println("用"+name+"打电话");
    }
    public void sendmessage(String name){
    System.out.println("用"+name+"发短信");
    }
}

public class phone_test {
//创建对象
public static void main(String[] args) {
    phone p = new phone();
    System.out.println("品牌："+p.brand);
    System.out.println("颜色："+p.color);
    System.out.println("价格："+p.price);

    p.brand = "华为";
    p.price = 2999;
    p.color = "红色";
    System.out.println("品牌："+p.brand);
    System.out.println("颜色："+p.color);
    System.out.println("价格："+p.price);
    p.call("林青霞");
    p.sendmessage("林青霞");
}
}

输出结果：

品牌：null
颜色：null
价格：0
品牌：华为
颜色：红色
价格：2999
用林青霞打电话
用林青霞发短信

对象内存图：

一个对象的内存图：

一个对象的基本初始化过程

图解：

两个对象的内存图：

方法的共用

图解：

2个对象的内存图：

两个引用指向同一个堆内存：

只要有一个改变了堆内存的数据，另一个一定也改变了

图解：

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

A：在类中的位置不同

成员变量：在类中方法外

局部变量：在方法中或者方法声明上（形式参数）

B：在内存中的位置不同

成员变量：在堆内存

局部变量：在栈内存

C：生命周期不同

成员变量：随着对象的创建而创建，随着对象的消失而消失

局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

D：初始化值不同：

成员变量：有默认值

局部变量：没有默认值，必须先定义，赋值，最后使用

public class variable_Demo {
    int x;
    public void show(){
        int y = 10;
        System.out.println(x);
        System.out.println(y);
    }

}

private关键字：

直接使用对象名访问成员变量，会存在数据的安全问题

这个时候，我们就要思考能不能让外界不要直接访问成员变量

这时候就要用到private关键字

private ：

是一个修饰符

可以修饰成员变量，也可以修饰成员方法

被private修饰的成员只能在本类中被访问

针对被private修饰的成员变量，我们会相应输出getXxx（）和setXxx（）用于获取和设置成员变量的值

方法用public修饰

public class Student {
String name;
private int age;
public void setAge(int a ){
    if(a<0||a>200){
        System.out.println("您输入的信息有误");
    }else{
        age = a;
    }
}
public int getAge(){
    return age;
}

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

public class Student_Test {
    public static void main(String[] args) {
        Student s = new Student();
        s.show();
        s.name = "林青霞";
        s.setAge(30);
        s.show();
    }
}

输出结果：

null...0
林青霞...30

标准案例2：

public class Student {
private String name;
private int age;
public void setName(String n){
    name = n;
}
public String getName(){
    return name;
}
public void setAge(int x){
    age = x;
}
public int getAge(){
    return age;
}
}

public class Student_test1 {
    public static void main(String[] args) {
        Student s = new Student();
        System.out.println(s.getName()+"..."+s.getAge());
        s.setAge(30);
        s.setName("林青霞");
        System.out.println(s.getName()+"..."+s.getAge());
    }
}

输出结果：

null...0
林青霞...30

封装：

A:封装概述

是面向对象三大特征之一

是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。就像刚才说的年龄。

B:封装原则：

将不需要对外提供的内容都隐藏起来。

把属性隐藏，提供公共方法对其访问。

成员变量private，提供对应的getXxx()/setXxx()方法

C:好处：

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

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

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 class Student_test1 {
    public static void main(String[] args) {
        Student s = new Student();
        System.out.println(s.getName()+"..."+s.getAge());
        s.setAge(30);
        s.setName("林青霞");
        System.out.println(s.getName()+"..."+s.getAge());
    }
}

构造方法：

构造方法：用于对对象的数据进行初始化

格式：

方法名和类名相同

没有返回值类型，连void都不用写

无具体返回值

调用：

通过new关键字即可

格式：类名对象名 = new 构造方法名（...）

public class Student {
    public Student(){
        System.out.println("这是种构造方法");
    }
}

public class Student001 {
    public static void main(String[] args) {
        Student St = new Student();
    }
}

构造方法的注意事项：

A:如果我们没有给出构造方法，系统将给出一个默认的无参数构造方法供我们使用

B:如果我们给出了构造方法，系统将不再提供默认的构造方法供我们使用。

这个时候，我们如果还想使用无参数构造方法，就必须自己提供。

我们推荐：自己给出无参数构造方法。

C：构造方法也是可以重载的。

给成员变量赋值的方式：

A：通过setXxx（）

B：通过构造方法

public class Student {
//    public Student(){
//        System.out.println("这是种构造方法");
//    }
    private String name;
    private int age;
    public Student(){}
    public Student(String name){
        this.name = name;
    }
    public Student(int age){
        this.age = age;
    }
    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }
    public void show(){
        System.out.println(name+"...."+age);
    }
}

public class Student001 {
    public static void main(String[] args) {
        Student St = new Student();
        St.show();
        Student s = new Student("林青霞");
        s.show();
        Student s1 = new Student("林青霞", 30);
        s1.show();

    }
}

输出结果：

null....0
林青霞....0
林青霞....30

标准类代码写法和测试：

A:类:

a:成员变量

b:构造方法

无参构造方法

带参构造方法

c:成员方法

getXxx()

setXxx()

B:给成员变量赋值的方式

a:无参构造方法+setXxx()

b:带参构造方法

案例代码：

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 class student_test {
    public static void main(String[] args) {
        Student s = new Student();
        s.setAge(30);
        s.setName("林青霞");
        System.out.println(s.getName()+"..."+s.getAge());
        Student s2 = new Student("林青霞",30);
        System.out.println(s2.getName()+"..."+s2.getAge());
    }
}

输出结果：

林青霞...30
林青霞...30

big coke

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java基础篇之面向对象篇

面向对象：面向对象思想概述：当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了，这时就开始思索，能不能把这些步骤和功能在进行封装，封装时根据不同的功能，进行不同的封装，功能类似的用一个类封装在一起，这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。面向对象思想：面向对象是基于...
复制链接

扫一扫