九、Java面对对象

面向对象编程（OOP）

java的核心思想

面向过程

思想：

  • 步骤清晰简单，第一步做什么，第二步做什么...
  • 适合处理一些较为简单的问题

面向对象

  • 思想：

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

    • 适合处理复杂的问题，多人协作的问题

  • 本质：以类的方式组织代码，以对象的组织（封装）数据

  • 抽象

  • 三大特性：

    • 封装

    • 继承

    • 多态

方法回顾

方法定义

  • 修饰符 public
  • 返回类型 void、 int、 String
  • break和return的区别 break：跳出switch 结束循环 return：方法结束，返回一个结果
  • 方法名 ：见名知意 驼峰命名法
  • 参数列表
  • 异常抛出

方法调用

  • 静态方法

  • 非静态方法

    //静态方法  static  和类一起加载的
  直接调用其他类的方法
//非静态方法
  实例化类后调用

  • 形参和实参

  • 值传递和引用传递

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

    值传递：传递过去改变，本身值不会改变

  • this关键字

类与对象的关系

  • 类是一种抽象的数据类型
  • 对象是抽象概念的具体实例

创建对象

类是抽象的

类实例化后（new）会返回一个自己的对象

  • 使用new关键字创建对象

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

  • 也称为构造方法，是创建对象必须要调用的，并且构造器有两个特点

    • 构造器

      • 必须与类名相同

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

    • 作用

      • new本质是在调用构造方法
      • 初始化对象的值

    • 注意点

      • 定义有参构造之后，想使用无参构造，必须显示的定义一个无参构造

Alt+Insert快速构造

创建对象内存分析

小结

        1、类与对象
        类是抽象的 对象是一个具体的实例
        2、方法
        定义和调用
        3、对应的引用
        引用类型：除基本类型（8）
        对象通过引用来操作的：栈里面的  真实对象是在堆里的
        4、属性：成员变量
        默认初始化：
        数字：0 0.0
        char：u0000
        boolean:false
        引用类型：null
        修饰符 属性类型 属性名= 属性值
        5、对象的创建和使用
        - 必须使用new关键字创造对象 构造器
        - 对象的属性
        - 对象的方法
        6、类：
        静态的属性
        动态的行为

封装

高内聚， 低耦合

类的内部数据细节由自己完成， 尽量暴露少量的方法给外部使用

属性私有 get/set

意义:

  1. 提高程序安全性
  2. 隐藏代码实现细节
  3. 统一接口
  4. 系统可维护性
package com.oop.demo03;

public class Student {
    //属性私有
    private String name;
    private int id;
    private char sex;
    //提供一些可以操作这个属性的方法
    //提供一些public 的get、set方法

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

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

    public char getSex() {
        return sex;
    }

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

继承

extends

本质是对某一批类的抽象

子类继承了父类，就会有父类的所有方法（public）

Object

在java中所有的类都默认继承Object类

    //public 公共的
    //private 私有的  属性一般是私有的
    //protected 受保护的
    //default 默认的

Ctrl+H显示类的继承结构

Java中只有单继承，没有多继承！一个儿子只能有一个爸爸，一个爸爸可以有多个儿子

super

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

this和super区别

代表对象不同:

​ this:本身调用者这个对象

​ super:代表父类对象的应用

前提：

​ this:没有继承也能使用

​ super:只能在继承条件下才能使用

构造方法:

​ this():本类的构造

​ super():父类的构造

私有的无法被继承

父类
package com.oop.demo04;

//人
public class Person {
    //public 公共的
    //private 私有的  属性一般是私有的
    //protected 受保护的
    //default 默认的
    protected String name="woman";

    public Person() {
        System.out.println("父类的无参构造");
    }

    public void say(){
        System.out.println("说了一句话");
    }

}        

子类
package com.oop.demo04;

//学生 人
public class Student extends Person{
    private String name ="dy";

    public Student() {
        super();//super和this只能写一个 并必须放在第一行，定义有参构造要把无参构造也显示出来
        System.out.println("子类的无参构造");
    }

    public void say(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}
   

main函数
package com.oop;

import com.oop.demo04.Student;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say("小红");

    }
}

方法重写：重点——>多态

需要有继承关系

子类重写父类的方法（只有方法，不能属性）

方法名必须相同，参数列表必须相同

修饰符：范围可以扩大，不能缩小

抛出的异常：范围可以被缩小，但不能扩大

子类和父类方法必须一直，方法体不同

为什么要重写：

  1. 父类功能，子类不需要，或者不满足 Alt+Insert ：Override

多态

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

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

  2. 父类和子类，有联系 类型转换异常 ClassCastException

  3. 存在的条件：继承关系，方法需要重写，父类引用指向子类对象 father f1 = new Son()

    不能重写的有：

    static 方法。属于类，不属于实例

    final 常量 无法改变 在常量池里

    private

instanceof 和类型转换

  1. 父类引用指向子类对象
  2. 把子类转换为父类，向上转型；
  3. 把父类转换为子类，向下转型，强制转换
  4. 方便方法调用，减少重复的代码
父类
package com.oop.demo06;

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

子类
    package com.oop.demo06;

public class Student extends Person{
    public void go(){
        System.out.println("go");
    }
}


main
package com.oop;

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

public class Application {
    public static void main(String[] args) {
        Object object = new Student();
        System.out.println(object instanceof Object);
        System.out.println(object instanceof Person);
        System.out.println(object instanceof Student);
        System.out.println(object instanceof Teacher);
        System.out.println(object instanceof String);
        System.out.println("================");
        Person person = new Student();
        System.out.println(person instanceof Object);
        System.out.println(person instanceof Person);
        System.out.println(person instanceof Student);
        System.out.println(person instanceof Teacher);
        //System.out.println(person instanceof String);
        System.out.println("================");
        Student student = new Student();
        System.out.println(student instanceof Object);
        System.out.println(student instanceof Person);
        System.out.println(student instanceof Student);
        //System.out.println(student instanceof Teacher);
        //System.out.println(student instanceof String);

        //低转高的 直接转  高转低的  需要强转
        //高                   低
        Person ps = new Student();
        //将person转换为student类型 可以使用student类型的方法
        Student ps1 = (Student) ps;
        ps1.go();
        //子类转换为父类 会丢失方法
        Student sd = new Student();
        Person sd1=sd;

    }
}

static

package com.oop.demo07;

public class Person {
    {
        //代码块（匿名代码块） 执行在构造方法前
        //赋初始值
        System.out.println("匿名代码块");
    }
    static {
        //静态代码块
        //类一加载,就执行一次  第一个执行
        System.out.println("静态代码块");
    }

    public Person() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person p1=new Person();
        System.out.println("=======");
        Person p2=new Person();
    }
}

返回结果

静态代码块
匿名代码块
构造方法
=======
匿名代码块
构造方法

Process finished with exit code 0

抽象类

abstract 抽象类 子类继承它并实现抽象类中的抽象方法 extends 单继承

类为单继承 接口可以多继承

  1. 不能new抽象类，只能靠子类去实现
  2. 抽象方法必须在抽象类中，抽象类中可以写普通方法
抽象类
package com.oop.demo08;

//抽象类：类  extend：单继承   类是单继承 接口可以实现多继承
public abstract class Action {
    //只有方法名，没有具体实现
    public abstract void doSomething();
    //1.不能new抽象类，只能靠子类去实现：约束
}    

子类
package com.oop.demo08;

//抽象类的所有方法，子类都必须帮其实现  除非子类也是抽象的
public class A extends Action{
    @Override
    public void doSomething() {
		System.out.println("do");
    }
}

接口的定义与实现

普通类：只有具体实现

抽象类：具体实现和规范（抽象方法）都有

接口：只有规范 interface

接口的本质是契约

作用：

  1. 接口是一种约束
  2. 定义一些方法，让不同的人实现
  3. public abstract 方法
  4. public static final 属性
  5. 接口不能实例化，接口中没有构造方法
  6. 一个类可以实现多个接口 implement
  7. 类必须要重写接口中的方法
接口timer
package com.oop.demo09;

public interface TimeService {
    void timer();
}
   

接口user
package com.oop.demo09;

//接口需要有实现类
public interface UserService {
    //常量， public static final修饰
    int AGE=99;
    //接口中所有定义都是抽象的 public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}    

实现类
package com.oop.demo09;

//类可以实现接口
//实现了接口的类，就需要重写接口的方法
//接口可以实现多继承
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() {

    }
}

内部类

在一个类内部在定义一个类

posted @ 2021-08-11 16:00  盐汽水mua  阅读(41)  评论(0)    收藏  举报