面向对象

最新推荐文章于 2023-10-01 13:03:19 发布

asdwasc

最新推荐文章于 2023-10-01 13:03:19 发布

阅读量51

点赞数

本文链接：https://blog.csdn.net/asdwasc/article/details/114857607

版权

什么是面向对象

java的核心思想oop 面向对象编程 oo面向对象

面向过程

第一步做什么第二部做什么适合处理简单的问题

面向对象

分类的思维模式，对这些分类进行单独思考。最后对某个分类下进行面向对象过程的思索

面向对象分析整个系统，面向过程处理细微操作

本质

以类的方式组织代码，以对象的封装数据

抽象

抽取共同的特点

三大特性

封装

继承

多态

复习

静态调用 static类用类名.方法
非静态

实例化这个类 new

调用的类名实例名 = new 类名（）；

实例名.对象的属性；

实例名.调用的类方法名（）

形参和实参类型要对应
java都是值传递
引用传递

形式参数类型是引用数据类型参数，套他

创建对象与类

类是一类事务的整体描述，定义。

对象是一个具体的实例

一个项目应该只存在一个main方法

类的结构

pubil class 类名{

//属性；字段

方法

}

new创建对象

构造器即构造方法
- 无参构造
一个类即使什么都不写，也会存在一个不显示的无参构造方法，可在class文件里显示查看，但是在java文件中不显示。

核心作用
使用new关键字必须有构造器，new本质调用构造器
构造器一般用来初始化值
alt+inset 自动创建构造器
this. 表示当前类的 = 后面按为参数传进来的值
定义有参之后，如果使用无参构造，必须显示的写无参构造
构造器的方法名等于类名，如果写了有参构造器必须加上无参构造器

封装继承多态

封装

基本要求高内聚，低耦合只留少量方法给外部用

核心属性私有 private

提供一些可以操作属性的public接口方法 get / set方法使用alt+ins 自动生成

set 传入 get获得

   student xm = new student();
        xm.setName("小明");
        xm.setAge(1000);
        xm.setSex('男');
        System.out.print("名字："+xm.getName()+"\t");
        System.out.print( "年龄："+xm.getAge()+"\t");
        System.out.print("性别："+xm.getSex()+"\t");
名字：小明	年龄：-1	性别：男

通过封装可以规范数据，保护代码

private String name;    // 名字

    private int age;  // 学号

    private char sex;//性别



    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age>120||age<0){//输入错误年龄
            this.age = -1;


        }else {
            this.age = age;
        }
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        if (sex!='男'&&sex!='女'){
            this.sex = '?';


        }else {
            this.sex = sex;
        }
    }

继承

extends 扩展子类是父类的扩展

public clsaa student extend person{

}//学生继承人类这个类
//子类继承父类 就会拥有父类全部方法

super - 父类的参数 this - 当前的

父类的属性一般用protect 受保护的修饰
用 super 调用父类的参数或者方法
私有 private 无法被继承
调用父类构造器必须放在子类第一行不写默认调用父类无参构造器
super必须只能出现在子类的方法或构造方法中
super和this不能同时调用构造方法

区别
1. 代表对象不同：this 本身调用者这个对象 super 代表父类对象使用
2. 使用条件：this没有继承也能用，super只能在继承条件下使用
3. 调用构造方法： this（）；本类的构造 super（）；父类的构造

方法重写多态

父类引用指向子类

B b = new A（）；

b.test();

alt+ o 重写方法

//静态方法和非静态方法区别很大重写只和非静态方法有关关键词只能是public

重写需要有继承关系，子类重写父类的方法
参数列表必须相同方法重载：当前方法，名字相同，参数列表可以不同
修饰符:范围可以扩大，但是不能缩小 public>protected>Defaault>private
抛出异常：范围，可以缩小，但不能扩大： ClassNotFoundExcetion————》Exception 小到大

为什么需要重写

父类功能子类不一定需要，或者不一定满足

alt+ins ：overreid 重写

多态

动态编译：类型可扩展同样的方法根据发送对象不同采用多种不同行为方式

子类没用方法调用父类的子类重写了父类方法对象执行哪些方法,和右边关系不大

person s2 = new student();

 student s1 = new student();
 person s2 = new student();
        s1.son();
        s2.son();//子类重写父类方法 执行子类方法
        s1.eat();
        s2.eat();//父类没有eat方法 因此报错
        ((student)s2).eat();//高类型强制转换低类型成功

多态是方法的多态 属性不能多态
* 父类和子类有联系 否则报类型转换异常！ClassCastException
* 父类引用指向子类对象 father f1 = new son();
* static 方法属于类 不能重写
* final 常量
* private 修饰的方法

引用类型转换

instanceof 判断有没有父子关系 System.out.println(x instanceof y);能不能通过编译看xy有没有父子关系 ture 和false 主要看x指向的和y有没有父子关系
判断对象是什么类型

//object > String
//object > peron >student
//object > peron > teacher

Object  obj  =  new student();
System.out.println(obj instanceof student);
System.out.println(obj instanceof teacher);
System.out.println(obj instanceof String);

System.out.println(obj instanceof Object);
System.out.println(obj instanceof person);
true
false
false
true
true

向下转型，父类使用子类方法强制转换可能丢失一些方法（（student）obj）.方法

向上转型子转父可能丢失一些方法但是不转子类继承父类默认可以用父类方法

方便方法调用减少重复代码

static总结

静态代码块加载初始化数据类加载就执行且只执行一次

static {

sout（“静态代码块”）

}

匿名代码块

{

}

加载类执行循序静态代码块》匿名代码块》构造方法

匿名和构造方法加载对象执行一次一般用来初始化

静态导入包

import static …可以导入具体的方法

抽象类

abstract 修饰

在一个类上使用这个修饰

特点不能new 只能靠子类去实现他

可以有正常方法有抽象方法必须为抽象类

接口

和抽象类区别

抽象类可以有具体的方法

接口：只有规范，自己无法写方法专业的约束！约束和实现分离：面向接口编程

oo精髓

接口声明 interface

约束
定义方法让不同人实现
接口中默认方法 public abstract
常量默认为 public static final
不能实例化，没有构造方法
implements 可以实现多个接口
必须重写接口中方法

一个实现类

public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void timer() {

    }

    @Override
    public void add(String name) {

    }

    @Override
    public void delet(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

两个接口

public interface TimeService {
    void timer();
}

public interface UserService {
//    接口中所有定义都是抽象的
//    只能写返回值类型+方法名字简单的方发
//    接口都需要有实现类
    void add(String name);
    void delet(String name);
    void update(String name);
    void query(String name);
//    定义常量
    public static final int age = 99;
    int age1 = 99;


}

内部类

成员内部类

public class Outer {

    private int id=10;



    public void outer(){
        System.out.println("外部方法");
    }
    public class inter {
        public void in(){
            System.out.println("neibu");
        }
        public void getID(){
            System.out.println("id");
        }

    }

}

 public static void main(String[] args) {
        Outer outer = new Outer();
//            通过外部类实例内部类
        Outer.inter inter = outer.new inter();
        inter.getID();
        outer.outer();
        inter.in();



    }
}

局部内部类不推荐

        new Apple().eat();
        UserService userService = new UserService(){
            @Override
            public void Hello() {
                
            }
        };

            }
}

class Apple{
    public void eat(){
        System.out.println("gan");
    }
}

interface UserService{
void Hello();
}