java基础-面向对象（回顾）

最新推荐文章于 2022-02-09 12:45:55 发布

锋声

最新推荐文章于 2022-02-09 12:45:55 发布

阅读量708

点赞数 8

分类专栏： java基础文章标签： java

本文链接：https://blog.csdn.net/xikaifeng/article/details/120108612

版权

java基础专栏收录该内容

36 篇文章 0 订阅

订阅专栏

文章目录

1、初识面向对象
2、创建与初始化对象
- 2.1、构造器
- 2.2、内存分析
3、封装
4、继承
- 4.1、super 、this
- 4.2、方法的重写
5、多态
- 5.1、instanceof和类型转换
6、Static
7、抽象类(abstract)
8、接口(interface)
9、内部类

1、初识面向对象

1.1、面向过程、面向对象

1.1.1、面向过程

步骤清晰简单，第一步做什么，第二部做什么…
面向过程适合处理一些较为简单的问题

1.1.2、面向对象思想

物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
面向对象适合处理复杂的问题，适合处理需要多人协作的问题！
对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

1.2、什么是面向对象

面向对象编程（Object-Oriented Programming, OOP）
本质：以类的方式组织代码，以对象的组织(封装)数据。
抽象
三大特性
- 封装
- 继承
- 多态
从认识论的角度考虑是先有对象后有类。对象是具体的事物，类是对象的抽象。
从代码运行角度考虑是先有类后有对象。类是对象的模板。

1.3、类与对象的关系

类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但并不能代表某一个具体的事物。
- 动物、植物、手机、电脑…
- Person类、Pet类、Cat类等，都是用来描述/定义某一具体的事物应该具备的特点和行为。
对象是抽象概念的具体实例，如张三是人的一个具体实例、张三家里的狗旺财就是狗的一个具体实例。

2、创建与初始化对象

使用new来创建对象。
使用new关键字创建的时候，除了分配内存之外，还会给创建好的对象进行默认的初始化，以及对类中构造器的调用。
类中的构造器也被称为构造方法，创建对象时必须要调用。有以下特点：
- 必须和类的名字相同
- 没有返回类型，也不能写void
一个类即使什么都不写，也会存在一个默认的构造方法

2.1、构造器

public class Person {
    //一个类即使什么都不写，也会存在一个默认的无参构造方法
    //显示地定义构造器
    String name;
    
    //作用：1. 使用new关键字，本质是在调用构造器
    //2. 用来初始化对象的值
    public Person(){} //无参构造
    
    //有参构造 3.一旦定义了有参构造，无参就必须显示定义
    public Person(String name){
        this.name=name;
    }
	//Alt+insert 快捷键插入构造方法
}

2.2、内存分析

//定义一个宠物类
public class Pet {
    public String name; //默认 null
    public int age; 	//默认 0
    //无参构造

    public void shout(){
        System.out.println("叫了一声");
    }
}

//应用类，创建调用对象
public class Application {
    public static void main(String[] args) {
        
        Pet dog = new Pet();

        dog.name = "旺财";
        dog.age = 3;
        dog.shout();
    }
}

对象通过引用类型来操作：栈 - - ->堆

3、封装

该露的露，该藏的藏
- 我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据细节由自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
封装（数据的隐藏）
- 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，称为信息隐藏。
作用
- 提高程序的安全性，保护数据
- 隐藏代码的实现细节
- 统一接口
- 系统可维护性增加了

在这里插入图片描述

4、继承

继承的本质是对某一批类的抽象，从而实现对世界更好地建模。
extends的意思是”扩展“。子类是父类的扩展，使用关键字extends来表示。
Java中类只有单继承，没有多继承！一个类只能继承一个父类。
继承是类与类之间的一种关系，此外还有依赖、组合、聚合等。
继承关系的两个类，一个为子类（派生类），一个为父类（基类），子类继承父类。
子类和父类之间，从意义上讲应该具有”is a“的关系。

//学生类(子类)继承 人类(父类)
public class Student extends Person{ /*Person extends Object*/
    ...
}

子类继承了父类，就会拥有父类的全部方法，而private私有属性及方法无法继承。
在Java中，所有类，都默认直接或间接继承Object类 (Ctrl+H 可以查看类关系)
被final修饰的类，无法被继承（断子绝孙）。

4.1、super 、this

1、super()调用父类的构造方法，必须在构造方法的第一个
2、super必须只能出现在子类的方法或构造方法中
3、super()和this()不能同时调用构造方法，因为this也必须写在第一行

super与this的区别：super代表父类对象的引用，只能在继承条件下使用；this调用自身对象，没有继承也可以使用。

super(); //隐藏代码，默认调用了父类的无参构造，要写只能写第一行

在这里插入图片描述

4.2、方法的重写

1、重写：子类的方法必须与父类方法必须一致，方法体不同。
2、重写是方法的重写，与属性无关
3、重写方法只与非静态方法有关，与静态方法无关（静态方法不能被重写）

public class B {
    public static void test(){ //静态方法
        System.out.println("B==>test()");
    }
}

public class A extends B{ //继承
    public static void test(){
        System.out.println("A==>test()");
    }
}

public class Application {
    public static void main(String[] args) {
        //方法的调用之和左边定义的类型有关
        A a = new A();
        a.test(); //打印 A==>test()

        //父类的引用指向了子类，但静态方法没有被重写
        B b = new A();
        b.test(); //打印 B==>test()
    }
}

修改A.java, B.java

public class B {
    public void test(){ //非静态方法
        System.out.println("B==>test()");
    }
}
public class A extends B{
    @Override //重写了B的方法
    public void test() {
        System.out.println("A==>test()");
    }
}

//父类的引用指向了子类
B b = new A(); //子类重写了父类的方法，执行子类的方法
b.test(); //打印变成了 A==>test()
/* 
静态方法是类的方法，非静态方法是对象的方法
有static时，b调用了B类的方法，因为b是b类定义的
没有static时，b调用的是对象的方法，而b是A类new出来的对象，调用A的方法
*/

静态方法属于类，非静态方法属于对象
注意点：
1. 方法名、参数列表必须相同
2. 修饰符范围可以扩大，不能缩小
3. 抛出的异常范围可以被缩小，不能扩大
4. 被static(属于类，不属于实例)，final(常量方法)，private(私有)修饰的方法不能重写

5、多态

动态编译：类型
即同一方法可以根据发送对象的不同而采用不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用可以有很多
多态存在条件
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象

在这里插入图片描述

注意点：

多态是方法的多态，没有属性的多态
父类和子类，有联系类型转换异常: ClassCastException
存在条件：继承关系，方法需要重写，父类引用指向子类对象！

5.1、instanceof和类型转换

instanceof 引用类型比较，判断一个对象是什么类型

public static void main(String[] args) {

    // Object > String
    // Objest > Person > Student
    // Objest > Person > Teacher
    Object object = new Student();
	// X instanceof Y，X引用指向的对象是不是Y的子类
    System.out.println(object instanceof Student); //true
    System.out.println(object instanceof Person); //true
    System.out.println(object instanceof Teacher); //false
    System.out.println(object instanceof Object); //true
    System.out.println(object instanceof String); //false
	
    //类型之间的转化：父-子（高-低）,低可以转换为高
    Person obj = new Syudent(); //只能用Person方法（重写了用子类重写过的方法）
    (Syudent)obj.go(); //强转之后可以用Student方法(Student->go())
}

类型转换

父类引用指向子类的对象
把子类转换为父类，向上转型，会丢失自己原来的一些方法
把父类转换为子类，向下转型，强制转换，才调用子类方法
方便方法的调用(转型)，减少重复的代码，简洁。

6、Static

静态变量可以直接用类名访问，也称类变量。
静态变量(或方法)对于类，所有对象（实例）所共享。
静态区代码加载类时一起被初始化，最早执行且只执行一次（第一次new）。
Math->随机数:

//静态导入包
import static java.lang.Math.random;

public class Application {
    public static void main(String[] args) {

        //第一种随机数，不用导包
        System.out.println(Math.random()); //0.7562202902634543

        //第二种随机数，静态导入包
        System.out.println(random()); //0.5391606223844663
    }
}

7、抽象类(abstract)

abstract修饰的类就是抽象类，修饰的方法就是抽象方法。
抽象类中可以没有抽象方法，但有抽象方法的类一定要声明为抽象类。
抽象类不能使用new来创建对象，它是用来让子类继承的。
抽象方法只有方法的声明，没有实现，让其子类实现。
子类继承抽象类，必须实现抽象类的所有方法，否则该子类也要声明为抽象类。

//abstract 抽象类 类只能单继承（接口可以多继承）
public abstract class Action {

    //约束~有人帮我们实现~
    //抽象方法只有方法名，没有方法的实现
    public abstract void doSth();

    //1.不能new抽象类，只能靠子类去实现它，仅作为一个约束
    //2.抽象方法只能出现在抽象类中，抽象类可以有普通方法
    //3.抽象类有构造器，可以派生子类
    //4.抽象类的意义：约束，提高开发效率。但是类只能单继承，所以有局限 用的不多
}

8、接口(interface)

普通类：只有具体实现
抽象类：具体实现和规范(抽象方法)都有
接口：只有规范，没有方法实现，专业的约束！约束与实现分离：面向接口编程~
接口就是规范，定义的是一组规则，"你是什么…必须做什么…"的思想。
接口的本质是约束，就像人间法律一样，制定好大家都遵守。

//interface接口,接口都要有继承类
//实现类（implements 可以继承多个接口）
//多继承，利用接口实现多继承
public interface UserService {
    //定义的属性都是常量,默认修饰 public static final
    public static final int AGE = 99; //一般不用
    //所有的定义的方法都是抽象的 默认public abstract
    public abstract void run();
    void add();
    void query();
    void delete();
}

注意点

加粗样式接口没有构造方法，不能被实例化
实现类必须要重写接口中的方法
实现类（implements）可以实现多个接口

9、内部类

内部类就是在一个类的内部再定义一个类，比如A类中定义了一个B类，那么B就是A的内部类，而A相对B来说就是外部类

成员内部类：可以操作外部类的私有属性及方法
静态内部类：static修饰，不能访问外部类私有属性
局部内部类：外部类的方法里定义的类
匿名内部类：没有名字初始化类

在这里插入图片描述

视频学习地址：https://www.bilibili.com/video/BV12J41137hu?p=60

锋声

关注

8
点赞
踩
18

收藏

觉得还不错? 一键收藏
3
评论
java基础-面向对象（回顾）

1、初识面向对象1.1、面向过程、面向对象1.1.1、面向过程步骤清晰简单，第一步做什么，第二部做什么…面向过程适合处理一些较为简单的问题1.1.2、面向对象思想物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。面向对象适合处理复杂的问题，适合处理需要多人协作的问题！对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象来分析整个系统。但是，具体到微观操作，仍然需要面向过程
复制链接

扫一扫