java基础(六):面向对象

面向对象

面向对象:以类的方式组织代码,以对象组织数据

特性:

  1. 封装
  2. 继承
  3. 多态

类:抽象概念

对象:具体事物

  • 面向对象是java学习的重中之重,毕竟java就是一个面向对象的语言~
  • 类 = 属性+方法
  • 面向对象的概念适合复杂系统、多人协作
  • 从宏观上来说,java是面向对象的,但在微观上是面向过程的

创建

对象的创建

使用new实例化一个对象,如

Student student = new Student();//实例化对象

new时:

  • 内存空间的分配
  • 属性的初始化
  • 构造器的调用
  • 返回一个对象的引用(指针)

构造器

构造器在实例化时首先被自动调用,用于初始化参数。

new的本质是调用了构造器,返回一个对象

  • 名字和类名相同

  • 没有返回类型(不能写!)

  • 可以传参

  • this是一个指针,指向这个对象本身

    public class Person {
        String name;
        public Person(){
            //构造器
            this.name = "小明";
        }
    
    }
    

封装--访问控制

“高耦合,低内聚”,内部数据操作细节自己完成,不由外部干涉, 暴露少部分方法给外部使用。

封装:禁止访问对象的实际表示,而应该通过接口来访问。

修饰词:

  • public:可以由外部调用,公开使用
  • private:不可由外部调用
  • protected:由本包内或不同包的子类调用

继承

使用extend关键字,表示子类是父类的扩展

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

  • 子类拥有父类的全部public/protected方法和属性
  • 且子类可以对所有方法和属性重写
  • private属性无法被继承
  • java中所有类都是object类的子类

构造器

使用super可以访问到父类,构造器中super.generator()可以调用父类的构造器。

public class Person {
    String name;

    public Person(String name){
        //构造器
        this.name = name;
    }

}
public class Student extends Person{
    Student(String name){
        super(name);
    }
}
public class Demo2 {

    public static void main(String[] args){
        Student s = new Student("小明");
        System.out.println(s.name);
    }
}

输出“小明”。

如果在子类中不指定调用super,会自动调用

public class Person {
    String name;
    public Person() {
        //构造器
        System.out.println("父类Person无参数构造器执行");
    }
}
public class Student extends Person{
    Student(){
        System.out.println("子类Student无参数构造器执行");
    }
}

在new Student时输出:

若将子类构造器改为有参,仍然会首先调用父类的无参构造器

大致逻辑如下:

注:

  • 调用构造器时,需要将父类构造器调用语句放在子类构造器的第一句
  • 父类没写无参,默认有一个空的构造器函数
  • 如果写了一个有参构造器,那么父类就没有无参构造器了,子类不能自动调用构造器,即子类中必须显式调用有参构造器了。

方法重写

  1. Person类:
public static void test(){
        System.out.println("Person Test");
    }

Student类:

public static void test(){
        System.out.println("Student Test");
    }

调用:

public static void main(String[] args){
        Student s = new Student("小明");
        s.test();
    }

结果:

  1. 但是,如果修改main
public static void main(String[] args){
        Person s = new Student("小明");
        s.test();
    }

会导致输出:

这可以说明

  • 调用的方法根据声明的类型确定
  1. 以上结论来自于静态方法

    如果全部改为非静态,即将test改为无static修饰

     @Override
        public  void test(){
            System.out.println("Student Test");
        }
    

注意点:

  • override 的前提是继承
  • 方法名相同
  • 参数列表相同(不是重载)
  • 修饰符的范围只能扩大不能缩小 public>protected>default>private
  • 异常的范围可以被缩小但不能扩大,如:ClassNotFoundException->Exception

多态

定义

同一方法根据对象的不同采用不同的行为

引用类型

一个对象的实际类型是确定的,但引用类型并不一致

Student s = new Student();
Person s1 = new Student();
Object s2 = new Student();

实际类型都是Student,而引用类型可以是其任意父类

对于这样的对象s1/s2,如果没有static修饰,调用一个方法时

  1. 若子类父类都有该方法,且子类未重写:调用父类的方法

  2. 若都有,但子类重写了:调用子类的方法

  3. 若只有子类有,则无法调用(需要强制类型转换修改引用类型)

    如在Student写一个新的eat方法:

即能调用的方法取决于其引用类型而不是实际类型

方法修饰

  1. static 属于类,不属于对象,不可重写

  2. final 无法修改,不可重写

  3. private 只属于父类,无法重写

instanceof操作符

语法:

obj instanceof class
System.out.println(s instanceof Student);//true
        System.out.println(s1 instanceof Student);//true
        System.out.println(s1 instanceof Object);//true
        System.out.println(s2 instanceof Student);//true
        System.out.println(s2 instanceof Teacher);//false

如果对象的类是class或class的子类,则为True

在编译状态中,class可以是object对象的父类,自身类,子类。在这三种情况下Java编译时不会报错。(需要在同一条继承链上)

在运行转态中,class可以是object对象的父类,自身类,不能是子类。在前两种情况下result的结果为true,最后一种为false。但是class为子类时编译不会报错。运行结果为false。

编译的时候查看其引用类型判断是否报错。

运行的时候查看其实际类型判断是否为true。

强制类型转换

优先级:父类>子类。

子类转父类自动转换。

父类转子类需要强制转换。

转父类后部分方法可能无法再调用。


static

  • static修饰(静态)的从属于类,普通的从属于对象

  • 静态方法不能调用非静态成员

变量

静态变量(类变量)

  • 有static修饰的变量为静态变量,在该类的内存中只能存在一个,可以使用类名.变量名进行访问
  • 内部任何方法都可以直接访问静态变量(可以不使用类名.静态成员进行访问)
  • 类外部可以使用类名访问类中静态变量

实例变量

  • 无static修饰的变量

  • 每创建一个实例就会生成一个新的内存空间

  • 类内部只有非静态方法可以访问实例变量

  • 静态方法或其他类中只能通过实例对象访问

静态变量的作用

  • 静态变量被所有实例共享,可以作为实例对象间的共享数据
  • 如果所有实例都有一个相同的常量属性,可以定义为static以节省空间

方法

静态方法(类方法)

  • 静态方法不需要通过任何实例就可以被调用,
  • 不能使用this/super关键字
  • 也不能直接访问类内部的实例变量和实力方法
  • 可以直接调用类内部的静态变量和静态方法

实例方法

  • 通过实例对象访问

代码块

静态代码块

  • static{}代码块
  • 用于初始化类(一次性的),为类的静态变量赋初值
  • 类似于一个方法,但不在方法体中
  • 可以在类的任意位置,可以有任意多个
  • java虚拟机在加载类的时候执行静态代码块
  • 多个代码块按顺序运行
  • 静态代码块和静态方法类似,不能访问非静态成员

非静态代码块

  • {}
  • 创建对象时自动执行,不创建对象不执行
  • 代码域中的变量都是局部的,只在内部使用

抽象

abstract修饰

抽象类

  • abstract修饰的方法
  • 抽象类中可以有抽象方法和具体方法
  • 抽象类无法实例化

抽象方法

  • 抽象方法只声明没有方法体
  • 抽象方法必须在抽象类中
  • 子类重写父类时,必须重写父类的所有抽象方法
  • 不能用private修饰,因为private阻止重写

实例

public abstract class Shape {
    public int width; // 几何图形的长
    public int height; // 几何图形的宽

    public Shape(int width, int height) {
        this.width = width;
        this.height = height;
    }

    public abstract double area(); // 定义抽象方法,计算面积
}
public class Square extends Shape {
    public Square(int width, int height) {
        super(width, height);
    }

    // 重写父类中的抽象方法,实现计算正方形面积的功能
    @Override
    public double area() {
        return width * height;
    }
}
public class Triangle extends Shape {
    public Triangle(int width, int height) {
        super(width, height);
    }

    // 重写父类中的抽象方法,实现计算三角形面积的功能
    @Override
    public double area() {
        return 0.5 * width * height;
    }
}

接口

  • 普通类:只有具体实现
  • 抽象类:有具体实现和规范(抽象方法)
  • 接口:只有规范,没有具体实现 专业的约束,实现约束和实现的分离,比抽象类更加抽象

接口定义

[public] interface interface_name [extends interface1_name[, interface2_name,…]] {
    // 接口体,其中可以包含定义常量和声明方法
    [public] [static] [final] type constant_name = value;    // 定义常量
    [public] [abstract] returnType method_name(parameter_list);    // 声明方法
}
  • 接口只能继承接口
  • public定义的接口可以被任何类使用,而没有public只能被包内使用
  • 接口中的变量隐式声明为public static final(可以不写),即为常量,所以全部必须初始化
  • 接口中的方法隐式声明为 public abstract

接口实现

  • 一个类可以实现一个或者多个接口

  • 实现使用implements关键字

    <public> class <class_name> [extends superclass_name] [implements interface1_name[, interface2_name…]] {
        // 主体
    }
    
  • 与继承类似,可以获得所有的常量和方法

  • implements在extend后

  • 类实现接口后必须重写所有抽象方法

public interface IMath {
    public int sum();    // 完成两个数的相加
    public int maxNum(int a,int b);    // 获取较大的数
}
public class MathClass implements IMath {
    private int num1;    // 第 1 个操作数
    private int num2;    // 第 2 个操作数
    public MathClass(int num1,int num2) {
        // 构造方法
        this.num1 = num1;
        this.num2 = num2;
    }
    // 实现接口中的求和方法
    public int sum() {
        return num1 + num2;
    }
    // 实现接口中的获取较大数的方法
    public int maxNum(int a,int b) {
        if(a >= b) {
            return a;
        } else {
            return b;
        }
    }
}

内部类

类内部定义的类

分类:

  1. 成员内部类
  2. 静态内部类
  3. 局部内部类
  4. 匿名内部类
  • 内部类还是一个独立的类,会编译为独立的.class文件,但前面会冠以类名和$符号
  • 是内部类的一个成员,可以操作到外部类的私有属性
  • 外部类只有两种级别:public和默认
  • 内部类有四种级别:public、protected、private、默认
Outer o = new Outer();
//外部类可直接new
Inner in = new Inner();
//外部类外需要通过外部类来实例化内部类
Outer.Inner inner = o.new Inner();

实例内部类

没有static修饰,也成为非静态内部类,例:

public class Outer {
    class Inner {
        // 实例内部类
    }
}
  • 和实例方法、实例变量相同,在外部类/外部类以外,必须通过外部类的实例创建内部类的实例
  • 实例内部类中可以访问外部类的所有成员(多层嵌套也可)
  • 外部类中不能直接访问内部类的成员,而必须通过内部类的实例访问(不是很懂)
  • 实例内部类中的成员不能使用static修饰,除非同时有final修饰

静态内部类

static修饰的内部类,例:

public class Outer {
    static class Inner {
        // 静态内部类
    }
}
  • 可以通过外部类创建内部类的实例
  • 类中可定义静态成员/实例成员
  • 可直接访问外部类的静态成员,如果要访问外部类的实例成员,则需要通过外部类的实例去访问。

局部内部类

一个方法中定义的类,如:

public class Test {
    public void method() {
        class Inner {
            // 局部内部类
        }
    }
}
  • 类似局部变量,不用访问控制修饰符和static修饰符修饰
  • 只在方法内可用
  • 不能定义static成员
  • 内部类的内部类也不能用访问控制修饰符和static修饰符
  • 可访问外部类的所有成员
  • 方法中的成员与外部类成员同名,可以使用 .this. 的形式访问外部类中的成员。

匿名内部类

没有类名的内部类,直接使用new来声明,例:

new <类或接口>() {
    // 类的主体
};

一般用法:

  • 继承一个类,重写其方法。
  • 实现一个接口(可以是多个),实现其方法。
public class Out {
    void show() {
        System.out.println("调用 Out 类的 show() 方法");
    }
}
public class TestAnonymousInterClass {
    // 在这个方法中构造一个匿名内部类
    private void show() {
        Out anonyInter = new Out() {
            // 获取匿名内部类的实例
            void show() {
                System.out.println("调用匿名类中的 show() 方法");
            }
        };
        anonyInter.show();
    }
    public static void main(String[] args) {
        TestAnonymousInterClass test = new TestAnonymousInterClass();
        test.show();
    }
}
  • 和局部内部类相同,可访问外部类所有成员。若位于方法中,只能访问方法中final修饰的量
  • 可以使用非静态代码块进行初始化,在父类的构造函数后执行
posted @ 2023-02-05 22:49  Muling_m  阅读(135)  评论(0编辑  收藏  举报