自学java第七天：面向对象编程（第一部分）

于 2023-01-12 17:40:30 发布
阅读量73 收藏
点赞数
分类专栏： 自学java每日记录点滴 文章标签： java 开发语言 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50905233/article/details/128658863
版权
面向对象编程包括类和对象，强调封装、继承和多态三大特性。类是对象的抽象，对象是类的实例。文章介绍了方法定义、静态与非静态方法、参数传递、构造器以及对象的创建和初始化。此外，还讨论了继承的概念，强调了Java中单继承的特点以及super关键字的使用。
摘要由CSDN通过智能技术生成

  1. 初识面向对象

  • 面向过程思想

步骤清晰简单，第一步做什么，第二步做什么…..

面对过程适合处理一些较为简单的问题

  • 面向对象思想

物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。

面向对象适合处理复杂的问题，适合处理需要多人协作的问题!

对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

  1. 什么是面向对象

面向对象编程(Object-Oriented Programming, OOP)

面向对象编程的本质就是:以类的方式组织代码，以对象的组织(封装)数据。

抽象

三大特性:封装、继承、多态

从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象

从代码运行角度考虑是先有类后有对象。类是对象的模板。

  1. 回顾方法的定义

方法的定义

修饰符返回类型

break 和return的区别方法名

参数列表异常抛出

方法的调用

静态方法

非静态方法

形参和实参

值传递和引用传递

this关键字

import java.io.IOException;

//Demo01 类
public class Demo01 {
    //main方法
    public static void main(String[] args) {

    }
    /*
    修饰符  返回值类型  方法名（。。。）{
        //方法体
        return 返回值；
    }
     */
    //return 结束方法，返回一个结果
    public String sayHello(){
        return "Hello world";
    }
    public void print(){
        return;
    }
    public int max(int a,int b){
        return a>b?a:b;//三元运算符
    }
    //数组下表越界：Arrayindexoutofbounds
    public void readFile(String file) throws IOException {

    }
}
public class Demo02 {
    //静态方法 static
    //非静态方法
    public static void main(String[] args) {
        //对于静态方法，直接调用即可
        Student.say();
        //对于非静态方法
        //实例化这个类
        //new
        //对象类型 对象名 = 对象值
        Student student = new Student();
        student.say1();

    }
    //和类一起加载的
    public static void a(){

    }
    //类实例化之后才存在
    public void b(){

    }
}
public class Student {
    //静态方法
    public static void say(){
        System.out.println("学生说话了！");
    }
    //非静态方法
    public  void say1(){
        System.out.println("学生说话了！");
    }
}
public class Demo03 {
    public static void main(String[] args) {
        Demo03 demo03 = new Demo03();
//                            实参
        int sum = demo03.add(1,2);
        System.out.println(sum);

    }
//                  形参
    public int add(int a,int b){
        return a+b;

    }
}
public class Demo04 {
//值传递
    public static void main(String[] args) {
        int a= 1;
        System.out.println(a);//1
        Demo04.chang(a);
        System.out.println(a);//1

    }

    public static void chang(int a) {
        a = 10;

    }
}
//引用传递：对象，本质还是值传递

//对象，内存！

public class Demo05 {

    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);//null
        Demo05.change(person);
        System.out.println(person.name);//ZXL

    }

    public static void change(Person person) {
        //person是一个对象：指向---》Person person = new Person();这是一个具体的人可以改变属性
        person.name = "ZXL";

    }
}
//定义了一个Person类，有一个属性：name
class  Person{
    String name;
}

  1. 类与对象的关系

类是一种抽象的数据类型,它是对某一类事物整体描述/定义,但是并不能代表某一个具体的事物.

动物、植物、手机、电脑.....

Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为

对象是抽象概念的具体实例

张三就是人的一个具体实例,张三家里的旺财就是狗的一个具体实例。能够体现出特点,展现出功能的是具体的实例,而不是一个抽象的概念.

  1. 创建与初始化对象

使用new关键字创建对象

使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点:

必须和类的名字相同

必须没有返回类型,也不能写void

//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        //类：抽象的，需要实例化
        //类实例化后会返回一个自己的对象
        //student对象就是一个Student类的具体实例
        Student xiaoming = new Student();
        Student xiaohong = new Student();

        xiaoming.name = "小明";
        xiaoming.age = 3;
        xiaohong.name = "小红";
        xiaohong.age = 3;

        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);
        System.out.println(xiaohong.name);
        System.out.println(xiaohong.age);
    }
}
//学生类
public class Student {
    //属性：字段
    String name;//null
    int age;//0
    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }

}
public class Person {
    //一个类即使什么都不写，它也会存在一个方法
    //显示的定义构造器
    String name;

    //实例化初始值
    //1.使用new关键字。本质是在调用构造器
    //2.用来初始化值
    public Person(){
        this.name = "ZXL";

    }

    //有参构造,一旦定义了有参构造，无参必须显示定义
    public Person(String name){
        this.name = name;

    }

}
/*
public static void main(String[] args) {

        //new 实例化了一个对象
        Person person = new Person("ZXL");

        System.out.println(person.name);//ZXL

    }
    构造器：
        1.和类名相同
        2.没有返回值
    作用：
        1.new本质在调用构造方法
        2.初始化对象的值
    注意点：
        1.定义有参构造之后，如果使用无参构造，显示的定义一个无参的构造
    快捷键：
        Alt + Insert生成构造器

        this.  = 
 */

  • 类与对象

类是一个模板：抽象，对象是一个具体的实例

  • 方法

定义、调用！

  • 对应的引用

引用类型： 基本类型（8）

对象是通过引用来操作的：栈----》堆

  • 属性：字段Field成员变量

默认初始化：

数字：0 0.0

char: u0000

boolean:false

引用：null

修饰符 属性类型 属性名 = 属性值

  • 对象的创建和使用

必须使用new关键字创造对象，构造器

对象的属性 Person.name

对象的方法 Person.say()

  • 类：

静态的属性 属性

动态的行为 方法

  1. 封装

该露的露，该藏的藏

我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉;低耦合:仅暴露少量的方法给外部使用。

封装（数据的隐藏)

通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

记住这句话就够了:属性私有，get/set

/*
1.提高程序安全性，保护数据
2.隐藏代码的实现细节
3.统一接口
4.系统可维护增加了
 */
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("ZXL");
        System.out.println(s1.getName());
        s1.setId(21019);
        System.out.println(s1.getId());
    }
}
public class Student {
    //属性私有
    private String name;    //姓名
    private  int id;    //学号
    private char sex;    //性别
    //提供一些可以操作这个属性的方法！
    //提供给一些public的get、set方法
    //get 获得这个数据
    public  String getName(){
        return this.name;
    }
    //set 给这个数据设置值
    public void setName(String name){
        this.name = name;

    }
    //alt + insert

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public char getSex() {
        return sex;
    }
//学习（）
    //睡觉（）

}

  1. 继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

extends的意思是“扩展”。子类是父类的扩展。

JAVA中类只有单继承，没有多继承!

继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。

继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。子类和父类之间,从意义上讲应该具有"is a"的关系.

object类

super

方法重写

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();
        int mymoney = student.getMoney();
        System.out.println(mymoney);
        student.text1();

    }
}
//在java中，所有的类都默认继承Object,
//Person人：父类
public class Person /*extends Object*/{
    //public
    //protected
    //default
    //private
    private int money = 10_0000_0000;
    public void say(){
        System.out.println("说了一句话");
    }
 public void print(){
        System.out.println("Person");
    }



    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}
//学生  is  人：派生类、子类
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person{
    public void print(){
        System.out.println("Student");
    }
    public void text1(){
        print();
        this.print();
        super.print();

    }     
}

super注意点：

  • super调用父类的构造方法，必须在构造方法的第一个

  • super必须只能出现在子类的方法或者构造方法中

  • super和this不能同时调用构造方法

this:

  • 代表的对象不同：

this本身调用这这个对象

super代表父类对象的应用

  • 前提

this没有继承也可以使用

super只能在继承条件才可以使用

  • 构造方法

this()本类的构造

super()父类的构造

zxinlia
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值