面向对象编程（oop）

最新推荐文章于 2024-06-13 13:56:32 发布

00GJian

最新推荐文章于 2024-06-13 13:56:32 发布

阅读量95

点赞数

分类专栏： JAVA学习

本文链接：https://blog.csdn.net/dazhaozhao6/article/details/114537024

版权

JAVA学习专栏收录该内容

9 篇文章 0 订阅

订阅专栏

面向对象编程（oop）

以类的方式组织代码，以对象的组织（封装）数据。
抽象。
三大特性（封装，继承，多态）。

方法的调用

static修饰表示静态方法，是和类一起加载的。
没有static修饰的类是非静态方法，是和对象一起初始化的，所以要比静态方法加载慢，以至于静态方法中没办法调用非静态方法。
java里面都是值传递。
一个类里面只能由一个public class，但是可以有多个class。

#值传递
public class Demo2 {
    public static void main(String[] args) {
        int a=1;
        System.out.println(a);

        change(a);
        System.out.println(a);
    }
    public static void change(int a){
        a=10;
    }
}
#输出为1   1

#引用传递：传递的是对象，但是说到底还是值传递
public class Demo1 {
    public static void main(String[] args) {
        Person person = new Person();//new 实例化对象
        System.out.println(person.name);

        change(person);
        System.out.println(person.name);

    }
    public static void change(Person person) {
        person.name = "小子";
    }
}
//定义了一个Person类，有一个name属性
    class Person{
        String name;
    }
#输出为null   小子

类和对象的创建

类是抽象的，对象是具体的，对象通过new 类型来创建。
在对象被创建的时候，除了会分配空间，还会对创建好的对象有一个初始化，以及对类中的构造器进行调用。
一个类即使什么都不写，在编译成class文件之后，也有一个默认的方法，方法名字与类型相同，这个方法就叫做构造方法。
构造方法的名字必须和类名字相同。而且必须没有返回类型，也不能写void。（IDEA里面可以用alt和insert自动生成构造器）
在new一个类之后，实际上就是去调用这个类的构造器，但是如果定义了一个有参数的构造器，那么无参的构造器也一定要写出来。
构造器的两个作用，第一个就是使用new关键字，本质就是在调用构造器。第二个就是用来初始化值。
this指的是在这个类里面的变量，不是指方法里面的形参。

封装（数据的隐藏）

高内聚，低耦合。

1.高内聚：类的内部数据操作细节自己完成，不需要外部干涉。

2.低耦合：仅暴露少量的方法给外部使用。
属性私有：get/set方法。

继承（extend)

JAVA中类只有单继承。
所有的类都默认继承Objectl类。
子类继承父类的非private属性和方法。
在实例化子类的时候，首先先去调用父类的构造方法，可以写super(),也可以不写，隐藏，再去调用子类的构造方法。并且super()调用父类的构造方法只能在子类构造器的第一行调用。
this是调用本类的属性和方法。super是调用父类的属性和方法。
super和this不能同时调用构造方法。
super必须在继承条件下才可以用。

方法的重写（继承的前提条件）

A a=new a();
a.test();
//父类的引用指向了子类
B b=new a();
b.test();

A类继承于B类，A类重写了B类的test()方法。

#1.如果说test（）是静态方法，那么调用这个方法输出的结果只和左边右边。
#2.如果说test（）不是静态方法，那么就发生了方法重写，并且调用方法之后都是调用的子类重写的方法。
#3.重写的条件 方法名必须相同，参数列表必须相同   修饰符只能够扩大   抛出的一场只能被缩小，不可以扩大。
#4.看这个实例之后的类能执行什么方法主要是看左边。B b=new a();，如果说a里面没有重写test()方法，那么就调用b里面的，如果重写了，就调用a的。但是如果b里面没有，a里面有，那么就没有办法调用这个方法。

多态

一个对象是可以确定的，但是对象的引用是不一定的。比如说父类可以去指向子类。（B b=new a();）
多态是方法的多态，属性没有多态。
父类和子类才可以发生多态，就是对象的引用是不确定的。
存在的条件：继承关系，方法需要重写，父类的对象指向子类。
无法重写的时候：static 方法，和类一起加载，是属于类的，它不属于实例。 final常量。 private方法。

instanceof和类型转换

instanceof就是用来判断是否父类的。（A instanceof B A是不是B的父类）

抽象类（abstract）

抽象方法就是用abstract修饰，并且只有方法名，没有方法体，继承抽象类的子类必须重写类中的所有方法，除非子类也是abstract类。
java的类只支持单继承，但是接口可以多继承。
抽象类不能new出来，只能有子类去继承。
抽象类中可以写非抽象方法，但是抽象方法必须在抽象类中。

接口

接口是用interface声明，类的关键字是class。
接口继承使用implements，并且支持多继承，要重写接口中的全部方法。
接口中的方法默认都是public abstract。声明的常量默认都是public static final。
接口不能被实例化，接口也没有构造方法。

内部类

成员内部类

public class Outer(){
    private int id;
    public void out(){
        System.out.println("外部类");
    }
    public class Inner{
        public void in(){
            System.out.println("内部类");
        }
    }
}

实例化方式：Outer outer=new Outer();
		  Outer.Inner inner=outer.new Inner();

#内部类可以访问外部类的常量和私有属性和私有方法。

静态内部类

public class Outer(){
    private int id;
    public void out(){
        System.out.println("外部类");
    }
    public static class Inner{
        public void in(){
            System.out.println("内部类");
        }
    }
}