首页 > 编程语言 >java基础：面向对象

java基础：面向对象

时间：2023-02-05 22:55:20浏览次数：49  
标签：java 子类 基础 public 面向对象 实例 static Student class

面向对象

面向对象：以类的方式组织代码，以对象组织数据

特性：

  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修饰的量
  • 可以使用非静态代码块进行初始化，在父类的构造函数后执行

标签：java,子类,基础,public,面向对象,实例,static,Student,class
From： https://www.cnblogs.com/muling1m/p/17094133.html

相关文章

  • jmeter性能测试出现java.net.BindException: Address already in use: connect
    使用jmeter进行性能测试时，如果压测的线程比较多，可能会出现java.net.BindException:Addressalreadyinuse:connect压测机系统window10  问题原因：是因为压测机......
  • 谈谈我对Java的认识
    我对java的理解java的三大版本java是一种面向对象的编程语言，我们把它分为三种版本： java程序使用前的准备工作JDK：java开发的环境（其作用大于JRE）JRE：java运行......
  • Java多线程02——线程的生命周期和状态调度
    1线程的生命周期在线程的生命周期中，要经过新建​​new​​、就绪​​runnable​​、运行​​running​​、阻塞​​blocked​​和死亡​​dead​​5种状态。当线程启动后，......
  • 52面向对象-多态
    packagechapter04;publicclassJava13_Object{publicstaticvoidmain(String[]args){//TODO面向对象-多态//多态指一个对象在不同场景下......
  • 《SQL基础》10. 存储引擎
    目录存储引擎MySQL体系结构存储引擎简介三种经典存储引擎InnoDB逻辑存储结构MyISAMMemory区别及特点存储引擎选择存储引擎MySQL体系结构连接层最上层是一些客户端......
  • mysql基础知识
    1、sql注入sql注入就是通过把sql命令注入到后台数据库执行一些恶意的操作。注入方式比如通过web表单提交一些恶意字符串。比如用户做登录验证的时候，我们可能会根据用户填......
  • Java中使用etcd，包括基本的set、get、超时设置，watch监听等
    etcd的使用文章。etcd来zookeeper类似，常用的主要有set，get，getPrefix：获取指定前缀的所有数据，grant：key的超时设置，watch：监听回调事件，watchPrefix：监听某个前缀的事件，keepAlive：为......
  • Java JDK1.5： 泛型 新特性的讲解说明
    JavaJDK1.5：泛型新特性的讲解说明每博一文案听到过这样一句话：“三观没有标准。在乌鸦的世界里，天鹅也有罪。”环境、阅历的不同，造就了每个人独有的世界观、人生观、价......
  • 看一遍就懂，详解java多线程——volatile
    多线程一直以来都是面试必考点，而volatile、synchronized也是必问点，这里我试图用容易理解的方式来解释一下volatile。来看一下它的最大特点和作用：一使变量在多个线程间可见......
  • Java简单实现滑动窗口
    由于最近有一个统计单位时间内某key的访问次数的需求，譬如每5秒访问了redis的某key超过100次，就取出该key单独处理。这样的单位时间统计，很明显我们都知道有个边界问题，譬如5秒......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99