面向对象OOP

面向对象OOP

1初识面向对象

面向过程&面向对象

  • 面向过程思想(线性)
    • 步骤清晰简单,第一步做什么,第二步做什么……
    • 面向过程适合处理一些较为简单的问题
  • 面向对象思想(分类)
    • 物以类聚,分类的思维模式,思考问题首先会解决问题需要哪些类,然后对这些类分类进行单独思考,最后,才对某个类下的细节进行面向过程的思索
    • 面向对象适合处理复杂的问题,适合处理需要多人协作的问题
  • 对于描述复杂的事务,为了从宏观上把握、从整体上分析,我们需要使用面向对象的思路来分析整个系统。但是具体到微观操作,仍然需要面向过程的思路去处理。

什么是面向对象

  • 面向对象编程(Object Oriented Programming,OOP)
  • 面向对象编程的本质:以类的方法组织代码,以对象的组织(封装)数据
  • 抽象
  • 三大特征
    • 封装
    • 继承
    • 多态
  • 从认识论角度考虑,首先有对象后有类。对象,是具体的事物。类,是抽象的,是对对象的抽象
  • 从代码运行角度考虑是先有类后有对象。类是对象的模板。

2方法的回顾和加深

  • 方法的定义
    • 修饰符
    • 返回值类型
    • break和return的区别:break:跳出switch,结束循环
    • 方法名:注意规范,见名知意
    • 参数列表:(参数类型 参数名)……
    • 异常抛出
  • 方法的调用:递归
    • 静态方法
    • 非静态方法
    • 形参和实参
    • 值传递和引用传递
    • this关键字

//值传递:java
public class Demo04 {
    public static void main(String[] args) {
        int a = 1;//1
        System.out.println(a);//1
        
        Demo04.change(a);
        
        System.out.println(a);//1
        
    }
    //返回值为空
    public  static void change(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);//xiaomo
    }
    public  static void change(Person person){
        person.name = "xiaomo";
    }
}
//定义了一个Person类,有一个属性:name
class Person{
    String name;//null
}

3对象的创建分析

类与对象的关系

  • 类是一种抽象的数据类型,它是对某一类事物的整体描述/定义,但是并不代表某一个具体的事物
    • 动物、植物、手机、电脑。。。
    • Person类、Pet类、Car类等,这些类都是用来描述或者定义某一类具体事物应该具备的特点和行为
  • 对象是抽象概念的具体实例
    • 张三就是人的具体实例,张三家里的旺财就是狗的具体实例。
    • 能够体现出特点,展现出功能的是具体的实例,而不是一个抽象的概念。
package com.oop.demo02;
//学生类
public class Student {
    //属性:字段
    String name;
    int age;

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

//学程序号?对世界进行更好的建模!
package com.oop.demo02;
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        //类:抽象的,实列化
        //类实列化后会返回一个自己的对象!
        //student对象就是一个student类的具体对象
        Student xh = new Student();
        Student xiaoming = new Student();

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

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

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

创建与初始化对象

使用new关键字创建对象
使用new关键字创建的时候,除了分配内存空间之外,还会给创建好的对象 进行默认的初始化以及对类中构造器的调用。
类中的构造器也称为构造方法,是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:
1.必须和类的名字相同
2.必须没有返回类型,也不能写void
构造器必须要掌握

package com.oop.demo02;

//java--->Class
public class Person {
    //一个类即使什么都不写,他也会存在一个方法
    //显示的定义构造器
    String name;
    //1.使用new关键字必须要有构造器
    //2.用来初始化值
    public Person(){
        this.name="xiaoqiang";
    }
    
    //有参构造:一旦定义了有参构造,无参构造必须显示定义
    public Person(String name){
        this.name = name;
    }
}
/*
public static void main(String[] args) {
        //new 实列化了一个对象
        Person person = new Person();

        System.out.println(person.name);
    }
    构造器:
        1.和类名相同
        2.没有返回值
     作用
        1.new 本质是在调用构造器
        2.初始化对象的值
     注意点:
        1.定义了有参构造之后,如果想使用无参构造,显示的定义一个无参的构造
        
            //alt+insert
            this. =
        */

总结:

1.类与方法:类是一个模板:抽象,对象是一个具体的实例

2.方法:定义,调用

3.对象的引用:

	引用类型:基本类型(8)

​ 对象是通过引用来操作的: 栈--->堆

4.属性:字段Field 成员变量

默认初始化

​ 数字:0 0.0

​ char: u0000

​ bollean:false

​ 引用:null

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

5.对象的创建和使用

​ -必须使用new关键字创造对象,构造器 Person person = new Persion();

- 对象的属性  person.name
- 对象的方法 person.sleep()

6.类:

​ 静态的属性 属性

​ 动态的行为 方法

4面向对象三大特性

封装

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

package com.oop.demo04;
//类    private:私有
public class Student {
    //属性私有
    private String name;//姓名
    private int age;//年龄
    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 getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age>120||age<0){//不合法
            this.age = 3;
        }else{
            this.age = age;
        }
    }
}
package com.oop;


import com.oop.demo04.Student;
/*
1.提高程序的安全性,保护数据
2.隐藏代码的实现细节
3.统一接口
4.系统的可维护性增加了
 */
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("小胖");
        System.out.println(s1.getName());
    }
}

继承

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

extends的意思是“扩展”。子类是父类的扩展。
JAVA中类只有单继承,没有多继承!

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

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

object类

super注意点:
  • super调用父类的构造方法,必须在构造方法的第一个
  • super必须只能出现在子类的方法或构造方法中
  • super和this不能同时调用构造方法
Vs this:
  • 代表的对象不同
    • this 本身调用者这个对象
    • super:代表父类对象的应用
  • 前提
    • this:没有继承也可以使用
    • super:只能在继承条件下才可以使用
  • 构造方法
    • this():本类的构造
    • super():父类的构造
方法重写

重写:需要有继承关系,子类重写父类的方法!

1.方法名必须相同

2.参数列表列表必须相同

3.修饰符:范围可以扩大但不能缩小:public>Protected>Default>private

4.抛出的异常:范围,可以被缩小,但不能扩大;ClassNotFoundException-->Exception(大)

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

为什么需要重写:

1,父类的功能,子类不一定需要,或者不一定满足!

Alt + Insert;override;

多态

  • 动态编译:类型:可扩展性
  • 即同一方法可以根据发送对象的不同而采用多种不同的行为方式
  • 一个对象的实际类型是确定的,但可以指向对象的引用类型有很多
  • 多态存在的条件
    • 有继承关系
    • 子类重写父类的方法
    • 父类引用指向子类对象
  • 注意:多态是方法的多态,属性没有多态性
  • instanceof(类型转换) 引用类型,判断一个对象是什么类型
package com.oop.demo06;


public class Person {
    public void run(){
        System.out.println("run");
    }
}
package com.oop.demo06;


public class Student extends Person{
    @Override
    public void run() {
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }
}
package com.oop;


import com.oop.demo05.A;
import com.oop.demo06.Person;
import com.oop.demo06.Student;

public class Application {
    public static void main(String[] args) {
        //一个对象的实际类别是确定的
        //new Student();
        //new Person();

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

        s2.run();//son子类重写了父类的方法,就执行子类的方法
        s1.run();//son
        //对象能执行哪些方法,主要看对象左边的类型,和右边的关系不大
        s1.eat();
        s2.eat();//报错---可以通过强转调用
    }
}

多态注意事项:

1.多态是方法的多态,属性没有多态

2.父类和于类,有联系,类型转换异常!ClassCastException!

3.存在条件:继承关系,方法需要重写,父类引用指向子类对象!Father fl = new Son();
不能重写,无多态1.static 方法,属于类,它不属于实例2.final 常量:3.private方法;

package com.oop;


import com.oop.demo05.A;
import com.oop.demo05.Teacher;
import com.oop.demo06.Person;
import com.oop.demo06.Student;

public class Application {
    public static void main(String[] args) {
        //Object>String
        //Object>Person>Person
        //Object>Person>Student
        Object object = new Student();

        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof String);//false

        Person person = new Student();
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof Object);//true
        System.out.println(person instanceof Teacher);//flase
        //System.out.println(person instanceof String);//编译报错

        Student student = new Student();
        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Object);//true
        //System.out.println(student instanceof Teacher);//编译报错
        //System.out.println(person instanceof String);//编译报错
        
        //System.out.println(x instanceof y)//能不能编译通过
    }
}
package com.oop;


import com.oop.demo06.Person;
import com.oop.demo06.Student;

public class Application {
    public static void main(String[] args) {
        //类型转换: 父    子
        
        //高                  低
        Person obj = new Student();
        //低到高,强转,子类转父类可能会丢失自己本来的一些方法
        Student student = (Student) obj;
    }
}

1、父类引用指向子类的对象

2、把子类转换为父类,向上转型:

3、把父类转换为子类,向下转型:强制转换

4、方便方法的调用,减少重复的代码:简介

封装、继承、多态!抽象类

package com.oop.demo07;

//static
public class Student {
    {
        //代码块(匿名代码块)
    }
    static {
        //静态代码块
    }
    private static int age;//静态的变量  多线程
    private double score;//非静态的变量
    public  void run(){
        
    }

    public static void go(){
        
    }
    public static void main(String[] args) {
        Student s1 = new Student();

        System.out.println(Student.age);
        System.out.println(s1.score);
        System.out.println(s1.age);
        
        new Student().run();
        go();
    }
}
package com.oop.demo07;

public class Person {
    //2:赋初值
    {
        System.out.println("匿名代码块");
    }
    //1:只执行一次
    static {
        System.out.println("静态代码块");
    }
    //3
    public Person(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person = new Person();
    }
}
package com.oop.demo07;

//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Test {
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
    }
}

final修饰断子绝孙

5抽象类和接口

抽象类

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

//abstract  抽象类:类extends:单继承  (接口可以多继承)
public abstract class Action {
    //约束-有人帮我们实现
    //abstract,抽象方法,只有方法的名字,没有方法的实现
    public abstract void doSomething();
    
    //1、不能new这个抽象类,只能靠子类去实现它:约束
    //2.抽象类中可以写普通的方法
    //3.抽象方法必须在抽象类中
    //抽象的抽象:约束
    //思考题? 抽象类不能new,那么存在构造器吗?
            //存在的意义是什么
}
package com.oop.demo08;

//抽象类的所有方法,继承了他的子类,都必须要实现他的方法,除非他的子类也是抽象类
public class A extends Action{
    @Override
    public void doSomething() {

    }
}

接口

  • 普通类:只有具体实现
  • 抽象类:具体实现和规范(抽象方法)都有!
  • 接口:只有规范!自己无法写方法 专业的约束! 约束和实现分离:面向接口编程
  • 接口就是规范,定义的是一组规则,体现了现实世界中“如果你是...则必须能..”的思想。如果你是天使,则必须能飞。如果你是汽车,则必须能跑。如果你好人,则必须干掉坏人;如果你是坏人,则必须欺负好人
  • 接口的本质是契约,就像我们人间的法律一样。制定好后大家都遵守。
  • OO的精髓,是对对象的抽象,最能体现这一点的就是接口。为什么我们讨论设计 模式都只针对具备了抽象能力的语言(比如c++、java、c#等),就是因为设计模式所研究的,实际上就是如何合理的去抽象。

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

package com.oop.demo09;


public interface TimeService {
    void time();
}
package com.oop.demo09;

//interface定义的关键字,接口都需要有实现类
public interface UserService {
    //接口中的所有定义其实都是抽象的public
    public abstract void run();
    //public abstract灰色可省

    //常量public static final
    public static final int AGE = 99;

    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}
package com.oop.demo09;

//抽象类:extends
//类 可以实现接口implements接口
//实现了接口的类,就必须重写接口中的方法

//多继承,利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void run() {

    }

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void time() {

    }
}

作用:
1.约束

2.定义一些方法,让不同的人实现

3.public abstract

4.public static final

5.接口不能被实例化,接口中没有构造方法

6.implements可以实现多个接口

7.必须要重写按口中的方法

6内部类和OOP实战

内部类

  • 内部类就是在一个类的内部在定义一个类,比如,A类中定义一个B类,那么B类相对A类来说就称为内部类,而A类相对B类来说就是外部类了。
  • 1.成员内部
  • 2.静态内部类
  • 3.局部内部类
  • 4.匿名内部类
package com.oop.demo10;

public class Outer {
    private int id;
    public  void out(){
        System.out.println("这是外部类的方法");
    }
    public class Inner{
        public void in(){
            System.out.println("这是一个内部类的方法");
        }
        //获得外部类的私有属性
        public void getId(){
            System.out.println(id);
        }
        
    }
}
package com.oop;


import com.oop.demo06.Person;
import com.oop.demo06.Student;
import com.oop.demo10.Outer;

public class Application {
    public static void main(String[] args) {
        //new
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
    }
}

package com.oop.demo10;

public class Outer {
  
}
//一个java类中可以有多个class类,但只能有一个public class类
class A{
    
}
package com.oop.demo10;

public class Outer {
    //局部内部类
    public void method(){
        class Inner{
            public void in(){
                
            }
            
        }
    }

}
package com.oop.demo10;


public class Test {
    public static void main(String[] args) {
        //没有名字初始化类,不用将实列保存到变量值
        new Apple().eat();
        
        new UserService(){

            @Override
            public void hello() {
                
            }
        };
    }
    
}
class Apple{
    public void eat(){
        System.out.println("1");
    }
}

interface UserService{
    void hello();
}
posted @   冬将尽,春可期  阅读(9)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· CSnakes vs Python.NET:高效嵌入与灵活互通的跨语言方案对比
· DeepSeek “源神”启动!「GitHub 热点速览」
· 我与微信审核的“相爱相杀”看个人小程序副业
· Plotly.NET 一个为 .NET 打造的强大开源交互式图表库
· 上周热点回顾(2.17-2.23)
点击右上角即可分享
微信分享提示