自学java第七天:面向对象编程(第一部分)

面向对象编程包括类和对象,强调封装、继承和多态三大特性。类是对象的抽象,对象是类的实例。文章介绍了方法定义、静态与非静态方法、参数传递、构造器以及对象的创建和初始化。此外,还讨论了继承的概念,强调了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()父类的构造

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值