2021-09-01 面向对象编程

最新推荐文章于 2022-04-19 18:59:47 发布

eyesofyou

最新推荐文章于 2022-04-19 18:59:47 发布

阅读量109

点赞数

分类专栏： java入门文章标签： java

本文链接：https://blog.csdn.net/weixin_45313244/article/details/120044559

版权

java入门专栏收录该内容

14 篇文章 0 订阅

订阅专栏

初始面向对象

面向过程VS面向对象

1、面向过程：步骤清晰，一步一步的，适合处理简单问题
2、面向对象：物以类聚，分类思想，先分类，然后在分别对每个类思考。四核处理复杂问题和多人合作完成

什么是面向对象（oop）

面向对象编程（oop）的本质：以类的方式组织代码，以对象的组织（封装）数据
抽象
三大特征：封装、继承、多态

方法回归和加深

break和return的区别

break：跳出switch，结束循环
return：方法结束，结束要与返回值类型一致。

异常抛出

throws Exception

类和对象的关系

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

对象的创建分析

1、使用new关键字创建对象
2、new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化及对类中构造器的调用
3、类中的构造器也叫构造方法，是进行创建对象的时候必要调用的：

必须和类的名称相同
必须没有返回类型，也不能写void
4、构造器必须要掌握

package oop;

public class Student {
    String name;
    int age;
    public Student(){
    }
    public void study(){
        System.out.println(this.age+"岁的"+this.name+"在学习");
    }
}

package oop;

public class Application {
    public static void main(String[] args) {
        Student student=new Student();
        student.name="张三";
        student.age=18;
        student.study();
    }
}

在这里插入图片描述

构造

1、无参构造

public Student(){
this.name="xiaomming";
}

2、有参构造

    public Student(String name){
    this.name=name;
    }

一旦定义了有参构造，无参构造就必须要显示出来

总结

1、类与对象
类是一个模板：抽象，对象第一个具体的实例
2、方法
定义，调用
3、对应的引用
引用类型：基本类型（8）
对象是通过引用来操作的：栈—>堆
4、属性：字段field成员变量
默认初始化：
数组：0 0.0
char：u0000
Boolean：false
引用：null

修饰符属性类型属性名 =属性值
5、对象的创建和使用

必须使用new关键字创建对象，构造器 Person xiaoming=new Person（）；
对象的属性：xiaoming.name
对象的方法;xiaoming.sleep

封装、继承、多态

面向对象三大特性

封装

设计程序要**“高内聚，低耦合”**。
高内聚是指类的内部数据操作细节自己完成，不允许外部干涉
低耦合是暴露少量的方法给外部使用

封装（数据的隐藏）
通常，应禁止直接访问一个对象中数据的实际表示，而应通过接口来访问，叫信息隐藏

属性私有，get/set

package oop.Demo03;

public class Student {
    private String name;//姓名
    private int id;//学号
    private char sex;//性别

    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;
    }
}

package oop.Demo03;

public class Application {
    public static void main(String[] args) {
        Student student=new Student();
        student.setName("小米");
        student.setId(12);
        student.setSex('女');
        System.out.println(student.getName()+"性别"+student.getSex()+"今年"+student.getId()+"岁");
    }
}

在这里插入图片描述

继承

1、继承的本质是对某一批类的抽象
2、extends 关键字，子类对父类的扩展
3、java中类只有单继承，没有多继承

继承是类和类之间的关系，类和类之间的关系还有依赖、组合、集聚等
继承关系的两个分别叫做子类，父类。子类和父类之间是is a关系。子类 is a 父类

object类
super
方法重写

package oop.Demo04;

public class Person {
    public int money=10_0000;
    public  void say(){
        System.out.println("说了一句话  ");
    }
}

package oop.Demo04;

public class Student extends Person {
}

package oop.Demo04;

public class Application {
    public static void main(String[] args) {
        Student student=new Student();
        student.say();
        System.out.println(student.money);
    }
}

在这里插入图片描述
在java中所有的类都默认直接或者间接的继承object类

单继承就是一个儿子只能有一个爸爸，一个爸爸可以有多个儿子

super关键字，当子类成员变量覆盖了父类的成员变量，只能读取子类的时候，想要读取父类的数据时，使用super关键字

package oop.Demo04;

public class Person {
    public int money=10_0000;
}

package oop.Demo04;

public class Student extends Person {
    public int money=10_0000_1222;
    //想要输出父类的，要使用super关键字
    public void test(int money){
        System.out.println(money);
        System.out.println(this.money);
        System.out.println(super.money);

    }

}

package oop.Demo04;

public class Application {
    public static void main(String[] args) {
        Student student=new Student();
       student.test(1000);
    }
}

在这里插入图片描述

package oop.Demo04;

public class Student extends Person {
    public Student(){
        super();
        System.out.println("Student执行了无参构造");
    }
    public int money=10_0000_1222;
    //想要输出父类的，要使用super关键字
    public void test(int money){
        System.out.println(money);
        System.out.println(this.money);
        System.out.println(super.money);
    }
}

子类构造器隐藏代码：调用了父类的无参构造
调用父类的构造器，必须要在自乐你构造器的第一行

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

VS this：
1、代表的对象不同
this：本身调用者这个对象
super：代表父类对象的引用
2、前提
this：没有继承也可以使用
super：只能在继承条件下才可以使用
3、构造方法：
this（）：调用的本类的构造
super（）：调用的父类的构造

方法的重写

package oop.Demo05;

public class B {
    public static void test(){
        System.out.println("你吃饭了没");
    }
}

package oop.Demo05;

public class A extends B{
    public static void test(){
        System.out.println("小米吃饭了没");
    }
}

package oop.Demo05;

import javafx.scene.chart.AxisBuilder;

public class Application {
    public static void main(String[] args) {
        A a = new A();
        a.test();

        B b =new A();
        b.test();

    }

}

在这里插入图片描述
父类的引用指向了子类 B b =new A();
方法的调用只和左边的有关，定义的数据类型有关

package oop.Demo05;

public class B {
    public void test(){
        System.out.println("B==>test()");
    }
}

package oop.Demo05;

public class A extends B{
    @Override
    public void test() {
        System.out.println("A==>test()");
    }
}

package oop.Demo05;

public class Application {
    public static void main(String[] args) {
        A a = new A();
        a.test();

        B b =new A();
        b.test();
    }

}

在这里插入图片描述
静态的方法和非静态的方法区别很大：
静态方法：方法的调用只和左边，定义的类型有关
非静态方法：子类重写了父类的方法

重写：需要有继承关系，而且是子类重写父类的方法
1、方法名必须相同
2、参数列表必须相同
3、修饰符：范围可以扩大，但不可以缩小 public>protect>default>private
4、抛出的异常：范围可以被缩小，但不能扩大：ClassNotFoundException–>Exception(大）

重写，子类的方法必须和父类要一致，方法体不同
为什么要重写：
1、父类的功能：子类不一定需要父类的功能，或者不一定满足
alt+insert：override

多态

即同一个方法可以根据发送对象的不同而采用多种不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

多态存在的条件
1、有继承关系
2、子类重写父类的方法
3、父类引用指向子类对象

注意：多态是方法的多态，属性没有多态
instanceof

package oop.Demo06;

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

package oop.Demo06;

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

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

package oop.Demo06;

public class Application {
    public static void main(String[] args) {
        Student student1=new Student();
        Person student2 = new Student();
        Object student3 = new Student();

        student2.run();
        student1.run();

        student1.eat();
        ((Student) student2).eat();
    }
}

在这里插入图片描述
一个对象的实际类型是确定的
可以指向的引用类型就不确定了:父类的引用指向子类
子类重写了父类的方法，执行子类的方法
对象能执行那些方法，主要看对象左边的类型，和右边关系不大

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

1、static 方法，属于类，它不属于实例
2、final 常量，无法修改
3、private 方法，私有不能重写

instanceof 类型转换，引用类型转换

package oop.Demo07;

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

package oop.Demo07;

public class Teacher extends Person {
}

package oop.Demo07;

public class Student extends Person {

}

package oop.Demo07;

public class Application {
    public static void main(String[] args) {
        Object object1 = new Student();
        System.out.println(object1 instanceof Student );
        System.out.println(object1 instanceof Teacher);
        System.out.println(object1 instanceof Person);
        System.out.println(object1 instanceof Object);
        System.out.println(object1 instanceof String);
    }
}

在这里插入图片描述
System.out.println(X instanceof Y);能不能编译通过取决于x和y之间是否存在父子关系，存在父子关系编译就通过，不存在编译就报错

类型转换

package oop.Demo08;

public class Person {
}

package oop.Demo08;

public class Student extends Person {

    public void go(){
        System.out.println("go");
    }
}

package oop.Demo08;

public class Application {
    public static void main(String[] args) {
      //类型之间的转换  
        //父 子
        
        //高                   低
        Person student =new Student();
        //高--->低  强制转换
        ((Student) student).go();
        
        
        //低--->高   子类转父类可能丢失一些自己本来的方法
        Student student1=new Student();
        Person person=student;
    }
}

总结：
1、父类引用指向子类对象
2、把子类转换为父类，是向上转型，可能存在方法丢失的情况
3、把父类转化成子类，是向下转型，强制转换
4、方便方法调用，减少重复的代码，简洁

static总结

加上static 就是静态，不然就是非静态的

package oop.Demo09;

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

    public static void main(String[] args) {
        Demo09 demo09 = new Demo09();
        System.out.println("+++++++++++++++++===");
        Demo09 demo091 = new Demo09();
    }
}

抽象类和接口

抽象类

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

abstract 抽象类
约束 ~有人帮我们实现
abstract 抽象方法，只有方法名字，没有方法的实现
抽象类的所有方法，继承了它的方法，都必须要实现它的方法~除非子类也是abstract
extends单继承
接口就可以是多继承
1、不能new这个抽象类，只能靠子类去实现它：约束~
抽象类，抽象出来，提高开发效率

package oop.Demo10;

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

package oop.Demo10;

//abstract 抽象类
public abstract class Action {
    //约束 ~有人帮我们实现
    //    //abstract 抽象方法，只有方法名字，没有方法的实现
    public abstract void doSomething();
}

package oop.Demo10;

public class Application {
    public static void main(String[] args) {
        A a = new A();
        a.doSomething();
    }
}

接口

普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有
接口：只有规范，自己无法写方法~专业的约束，约束和实现分离
接口就是规范，定义的是一组规则，体现了现实世界中“如果你是。。。则必须能。。。”的思想
接口的本质是契约
声明类的关键字是class，声明接口的关键字是interface

package oop.Demo11;

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 oop.Demo11;

public interface TimeService {
    void timer();
}

package oop.Demo11;

//抽象类 extends
//类 可以实现接口 implements 接口
//实现了接口的类，就需要重写接口中的方法

//多继承~利用接口可以实现多继承
public class UserServlet 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、定义一些方法，让不同的人实现~10—>1
3、public abstract
4、public static final
5、接口不能被实例化~，接口中没有构造方法
6、implements可以实现多个接口
7、必须要重写接口中的方法

内部类及OOP实践

内部类

内部类就是一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了
1、成员内部类

package oop.Demo12;

public class Outer {
    private int id=10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    class Inner{
        public void  in(){
            System.out.println("这是内部类的方法");
        }
        //获取外部类的私有属性
        public void getID(){
            System.out.println(id);
        }
    }
}

package oop.Demo12;

public class Application {
    public static void main(String[] args) {
        Outer outer=new Outer();
        outer.out();
        outer.new Inner().in();
        outer.new Inner().getID();

    }
}

在这里插入图片描述

2、静态内部类
静态内部类只能访问静态数据成员

package oop.Demo12;

public class Outer {
    private static int id=10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
   public static class Inner{
        public void  in(){
            System.out.println("这是内部类的方法");
        }
        //获取外部类的私有属性
        public void getID(){
            System.out.println(id);
        }
    }

}

正确的：
在这里插入图片描述
错误的

3、局部内部类

package oop.Demo13;

public class Outer {
    //局部内部类
    public void method(){
        class Inner{
            public void in(){
                System.out.println("这是局部内部类");
            }
        }
    }
}
一个java类中可以有多个class类，但是只能有一个public class类
//class A{
//
//}

4、匿名内部类

package oop.Demo13;

public class Test {
    public static void main(String[] args) {
        new A().eat();
    }
}
class  A{
    public  void eat(){
        System.out.println("这是匿名内部类");
    }
        }

一个java类中可以有多个class类，但是只能有一个public class类

eyesofyou

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2021-09-01 面向对象编程

面向对象编程初始面向对象面向过程VS面向对象什么是面向对象（oop）方法回归和加深break和return的区别异常抛出类和对象的关系对象的创建分析构造总结面向对象三大特性封装继承多态static总结抽象类和接口抽象类接口内部类及OOP实践内部类初始面向对象面向过程VS面向对象1、面向过程：步骤清晰，一步一步的，适合处理简单问题2、面向对象：物以类聚，分类思想，先分类，然后在分别对每个类思考。四核处理复杂问题和多人合作完成什么是面向对象（oop）面向对象编程（oop）的本质：以类的方式组织代码，
复制链接

扫一扫