2020-09-26面向对象

本文深入探讨面向对象编程(OOP)的基本概念与核心特性,包括封装、继承与多态等,通过实例说明如何利用这些特性进行高效编程。

面向对象

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

从认识角度:先有对象再有类,对象是具体的事物,类是抽象的一类对象,

从代码运行角度:是先有类后有对象,类是对象的模板

三大特性

封装

类的内部数据操作细节自己完成,不允许外部干涉,仅暴露少量的方法给外部使用。高内聚,低耦合。

属性私有(private):get/set

private String  name ;//名字
private  int id;//学号
//提供一些可以操作这个属性的方法
//get获得这个数据
public String getName(){
    return this.name;
}
//set 给这个数据设置初始值
public void setName(String name){
    this.name = name;
}

继承

继承的本质是对某一批类的抽象,从而实现对现实世界更好的建模,继承是类与类之间的关系,一个为父类,一个为子类。

(extands)就是扩展的意思,子类是父类的扩展。java中只有单继承,没有多继承。

注意:private不可以被子类继承,public可以被继承

​ 在Java中,所以的类都直接或者间接继承object类

​ super调用父类的无参构造要放在最前面,super必须出现在子类的方法或者构造方法中,super和this不能同时出现在构造方法。

public Student() {
    //隐藏代码:调用了父类的无参构造
    super();//调用父类的构造器,必须要在子类的构造器
    System.out.println("student无参实行");
}

super与this区别:

  1. 代表的对象不同:this表示本身调用者这个对象,super表示代表父类对象的应用
  2. 前提条件:this没有继承也可以使用,super只能在继承关系下使用
  3. 构造方法:this是本类的构造,super是父类的构造
重写

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

  1. 方法名必须相同
  2. 参数里列表必须相同
  3. 修饰符:范围可以扩大: Public>protected>default>private
  4. 抛出的异常:范围可以缩小不能扩大:ClassNotFoundException --> Exception(大)
public static void main(String[] args) {
    //静态方法与非静态的方法有很大区别
    // 非静态方法可以重写
A a = new A();
a.test(); //A

//父类的引用指向了子类
B b = new A();
b.test();  //B
}
public class B {
    public void test(){
        System.out.println("B=>test");
    }

}
public class A extends B {
    @Override//注解,有功能的注释,Override:重写
    public void test() {
        System.out.println("A=>test");
    }
}

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

为什么需要重写:

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

多态

动态编译:类型:可扩展性、

定义:同一个方法可以根据发送那个对象的不同而采用多种不同的行为方式

一个对象的实际类型是确定的,但可以指向对象的引用类型有很多

注意事项:

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

static 方法,属于类,不属于实例 final 常量 private 方法 这些方法都不可以重写

public static void main(String[] args) {

    //一个对象的实际类型确定的
    //new Student();
    //new Person();

    //可以指向的引用类型就不确定了
    Student s1 = new Student(); //student能调用的方法都是自己的或者继承父类的方法
    Person s2 = new Student();  //Perso 父类型,可以指向子类,达到你是不能调用子类独有的方法
    Object s3 = new Student();
    //对象具体执行那个方法,主要看对象左边的类型,与右边关系不大
    s2.run();
    s1.run();
    s1.eat();

}
public class Student extends Person{
    @Override
    public void run() {
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }
}
public class Person {
    public void run(){
        System.out.println("run");
    }
}
instanceof
//object > Person > Student
//object > Person > Teacher
Object object = new Student();

//System.out.println(X instanceof Y);  
System.out.println(object instanceof Student);      //true
System.out.println(object instanceof Person);       //true
System.out.println(object instanceof Teacher);      //false

Person person = new Student();
System.out.println(object instanceof Student);      //true
System.out.println(object instanceof Person);       //true
System.out.println(object instanceof Teacher);      //false

抽象类

//abstract 抽象类 ;类extends :单继承   (接口可以多继承)
public abstract class Action {
    //约束
    //abstract ,抽象方法,只有方法名字没有方法实现
    public abstract void doSomeThing();
    //不能new 抽象类,只能靠子类去实现
    //抽象类中可以写普通方法
    //抽象方法必须在抽象类中
}
public class A extends Action {
    public void doSomeThing(){

    }
}

接口

interface 可以多继承

  • 普通类:只有具体实现

  • 抽象类:具体实现和规范(抽象方法)都有

  • 接口:只有规范! 自己无法写方法 专业级的约束

    定义:接口就是规范,定义的是一组规则,体现了现实世界中如果你是,则必须干什么。

    接口的 本质是契约,是面向对象的精髓,是对对象的抽象。

    作用:约束,定义方法让不同的人实现,接口不能被实例化,接口中没有构造方法,implements可以实现多个接口,必须重写接口中的方法

public interface UserService {
    //接口中的所有定义的方法其实都是抽象的 Public abstract
    void add(String name);
    void delete(String name);
    void  update(String name);
    void  query(String name);
}
//类 可以实现接口
//实现了接口的类,就需要重写接口中的方法
public class UserServiceImpl  implements  UserService,TimeService{
    @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 timer() { }
}

构造器

类中的构造器也成为构造方法,是在进行创建对象的时候必须要调用的,并且构造器要有两个特点1:必须和类名相同2:必须没有返回值(注意也不能是void)

同时,定义有参构造后,如果想要使用无参构造,一定要显示的定义一个无参的构造

public class Person {
    //构造方法,自动会生成一个方法
    String  name;
    //实例化初始值
    //1:使用new关键字,本质是在调用构造器
    //用来初始化值
    //无参构造
    public  Person(){

    }
    //有参构造:一旦定义了有参构造,无参构造就必须显示定义,表现出来。
    public  Person(String name){
        this.name = name;
    }
    //alt + insert
}

一些快捷键

IDEA: alt + insert--------------- 快速生成构造函数

ctrl + h -------------------查看继承

ctrl + alt +T =======自动包裹代码

Typora: ctrl + shift +` ---------写代码块

ctrl +/--------------------------------源代码模式

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值