Java面向对象

初识面向对象

面向过程&面向对象

面向过程思想
- 步骤清晰简单，第一步，第二步
- 适合处理一些较为简单的问题
面向对象思想
- 分类的思维模式思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
- 适合处理复杂问题，适合处理需要多人协作的问题！
对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。
什么是面向对象
- 面向对象编程(Object-Oriented Programming, OOP)
- 面向对象的本质就是：以类的方式组织代码，以对象组织(封装)数据。
- 抽象
- 三大特性：
  - 封装
  - 继承
  - 多态
- 从认识论角度考虑是先有对象后有类。对象是具体的事物。类，是抽象的，是对对象的抽象
- 从代码运行角度考虑是先有类后有对象。类是对象的模板。

方法回顾

方法的定义

修饰符
返回类型
break:跳出switch，结束循环和return 的区别
方法名：注意规范见名知意
参数列表： (参数类型,参数名)...

异常抛出

package com.jiang.oop.Demo01;

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

    }

    /*
    修饰符 返回值类型  方法名(...){
        //方法体
        return 返回值;
     }
     */
    public String sayHello(){
        return "hello,world";
    }

    public int max(int a,int b){
        return a>b ? a : b;//三元运算符
    }
}

方法的调用：递归

静态方法

package com.jiang.oop.Demo01;

public class Demo02 {
    //静态方法 static
//    public static void main(String[] args) {
//        Student.say();
//    }

    public static void main(String[] args) {
        //实例化这个类 new
        //对象类型 对象名 = 对象值;
        Student student = new Student();

        student.say();
    }



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

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

    }
     */

}

package com.jiang.oop.Demo01;

//学生类
public  class Student {

    /*静态方法
    public static void say(){
        System.out.println("学生说话了");
    }*/

    //非静态方法
    public void say() {
        System.out.println("学生说话了");
    }
}

非静态方法
形参和实参

值传递和引用传递

package com.jiang.oop.Demo01;
//值传递
public class Demo04 {

    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);

        Demo04.change(a);
        System.out.println(a);//1

    }
    public static void change(int a){
        a=10; //10
    }
}

package com.jiang.oop.Demo01;
//引用传递:对象  本质还是值传递
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);//jiangjiang
    }

    public static void change(Person person){
        //person是一个对象:指向的 ---> Person person = new Person();这是一个具体的人，可以改变属性！
        person.name = "jiangjiang";
    }
}

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

this关键字

对象的创建分析

类于对象的关系

类是一种抽象的数据类型，它是对某一类事物整体描述/定义。但并不能代表某一个具体的事物。
对象是抽象概念的具体实例

创建与初始化对象

使用new关键字创建对象

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

package com.jiang.oop.Demo02;

//一个项目应该只存在一个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;

        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);

        xiaohong.name = "小红";
        xiaohong.age = 3;
        System.out.println(xiaohong.name);
        System.out.println(xiaohong.age);



    }
}

package com.jiang.oop.Demo02;

//学生类
public class Student {

    //属性：字段
    String name;//null
    int age;

    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }

}

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有两个特点：
- 1. 必须和类的名字相同
- 1. 必须没有返回值类型，也不能写void

构造器必须要掌握

package com.jiang.oop.Demo02;

public class Person {
    //一个类即使什么都不写，它也会存在一个方法
    //显式地定义构造器


    String name;

    //实例化初始值
    //默认构造器
    //1. 使用new关键字，必须要有构造器
    //2. 用来初始化值

    public Person(){
//        this.name = "jiangjiang";
    }


    //有参构造:一旦定义了有参构造，午餐就必须显示定义
    public Person(String name){
        this.name = name;
    }

    //alt+insert


}

/*
    public static void main(String[] args){
        //new 实例化了一个对象
        Person person = new Person("jiangjiang");
        System.out.println(person.name);//jiangjiang
    }



    构造器：
        1. 和类名相同
        2. 没有返回值
     作用：
        1. new 本质在调用构造方法
        2. 初始化对象的值
     注意点：
        1. 定义有参构造后，如果想要使用无参构造，显式地定义一个无参地构造
        
 */

面向对象三大特性

封装

程序设计要求 "高内聚,低耦合"
- 高内聚就是类的内部数据操作细节自己完成,不允许外部干涉
- 低耦合:仅暴露少量的方法给外部使用
封装(数据的隐藏)
- 通常,应禁止直接访问一个对象中数据的实际表示,而应该通过操作接口来访问,称为信息的隐藏
属性私有,get/set

package com.jiang.oop.Demo04;
//类 private : 私有
public class Student {

    //属性私有
    private String name;//名字
    private int id; //学号
    private int sex;//性别
    private int age;//年龄
    //学习()
    //睡觉()
    //提供一些public 的get、set方法
    //get 获得这个数据
    public String getName(){
        return this.name;
    }
    //set 给这个数据设置值
    public void setName(String name){
        this.name = name;

    }

    //alt + insert


    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if(age>120||age<0){
            this.age = 3;
        }else {
            this.age=age;
        }
    }


}


/*
 public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("jiangjiang");
        System.out.println(s1.getName());
        s1.setAge(-1);//不合法的
        System.out.println(s1.getAge());
    }
 */

/*
1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 系统的可维护性增加了
 */

继承

继承的本质是对某一批类的抽象,从而实现对现实世界更好的建模。
extends的意思是"扩展"。子类是父类的扩展。
JAVA中类只有单继承,没有多继承。
继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
继承关系的两个类,一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。
object类

super this

Super注意点：
    1. super调用父类的构造方法，必须在构造方法的第一个
    2. super必须只能出现在子类的方法或者构造方法中!
    3. super和this不能同时调用构造方法!

VS this:
   代表对象不同：
    this: 本身调用者这个对象
    super: 代表父类对象的应用
   前提:
    this:没有继承也可以使用
    super:只有在继承条件下才可以使用
    构造方法:
    this():本类的构造
    super(): 父类的构造

方法重写

重写:需要有继承关系，子类重写父类的方法！
    1. 方法名必须要相同
    2. 参数列表必须相同
    3. 修饰符: 范围可以扩大: public > protected > default > private
    4. 抛出的异常:范围, 可以被缩小, 但不能被扩大: ClassNotFoundException  --> Exception(大)

重写, 子类的方法和父类必须要一致, 方法体不同！

为什么需要重写:
    1. 父类的功能, 子类不一定需要, 或者不一定满足!
    Alt + Insert : override;

多态

即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的,但可以指向对象的引用的类型有很多(父类,有关系的类)
多态存在的条件
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象

注意:多态是方法的多态,属性没有多态性

package com.jiang.oop.Demo06;

public class Student extends Person{
    @Override
    public void run() {
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }
}
/*
   public static void main(String[] args) {
        //一个对象的实际类型是确定的
        // new Student();
        // new Person();

        //可以指向的引用类型就不确定了: 父类的引用指向子类
        Student s1= new Student();//Student能调用的方法都是自己的或者继承父类的！
        Person s2 =new Student();//Person父类型，可以执行子类，但是不能调用子类独有的方法
        Object s3= new Student();


        s2.run();
        s1.run();

        //对象能执行哪些方法，主要看对象左边的类型，和右边的关系不大
        s1.eat();
        ((Student) s2).eat();//子类重写了父类的方法，执行子类的方法

    }
 */

package com.jiang.oop.Demo06;

public class Person {
    public void run(){
        System.out.println("run");
    }

}

/*
多态注意事项：
1. 多态是方法的多态，属性没有多态
2. 父类和子类，有联系  类型转换异常！  ClassCastException!
3. 存在条件：  继承关系，方法需要重写 父类引用指向子类对象！  Father f1 = new Son();


    不能重写:
    1. static 方法, 属于类, 它不属于实例
    2. final 常量;
    3. private 方法;
 */

instanceof (类型转换)引用类型

抽象类和接口

抽象类

abstract修饰符可以用来修饰方法也可以用来修饰类,如果修饰方法,那么该方法就是抽象方法,如果修饰类,那么该类就是抽象类
抽象类中可以没有抽象方法,但是抽象方法的类一定要声明为抽象类.
抽象类,不能使用new关键字来创建对象,它是用来让子类继承的.
抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的.
子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类

接口

普通类:只有具体实现
抽象类:具体实现和规范(抽象方法)都有!
接口:只有规范!自己无法写方法专业的约束! 约束和实现分离: 面向接口编程
接口就是规范,定义的是一组规则,体现了现实世界中"如果你是...则必须能..."的思想.如果你是天使必须会飞...
接口的本质是契约
OO的精髓,是对对象的抽象,最能体现这一点的就是接口.为什么我们讨论设计模式都只针对具备了抽象能力的语言(比如C++ Java c#等),就是因为设计模式所研究的,实际上就是如何合理的去抽象

声明类的关键字是class,声明接口的关键字是interface

发表于 2022-04-22 23:00 姜新羽阅读(28) 评论(0) 编辑收藏举报

刷新页面返回顶部