第四章面向对象

Admin-fqw

已于 2022-07-17 17:18:16 修改

阅读量111

点赞数

分类专栏：面向对象多态继承文章标签： java 开发语言

于 2022-07-10 20:45:29 首次发布

本文链接：https://blog.csdn.net/m0_56280646/article/details/125710444

版权

面向对象同时被 3 个专栏收录

2 篇文章 0 订阅

订阅专栏

多态

1 篇文章 0 订阅

订阅专栏

继承

1 篇文章 0 订阅

订阅专栏

第四章面向对象

面向过程：分析出解决问题所需要的步骤，然后把步骤一步一步实现。

直接关注流程。

面向对象：以分类的方式进行思考和解决问题。先对整体关系作出分类，然后根据不同的类深入细节的处理。面向对象的思想符合人类的认知习惯。

面向对象与面向过程的联系：面向对象关注于从宏观上把握事物之间的关系，在具体到如何实现某个细节时，仍然采用面向过程的思维方式。面向对象如果离开了面向过程，就无法实现真正的落地，成为无源之水。

java类

类：类是一个模板，它描述一类事物的属性和行为的集合. 类是表示一个客观世界某类群体的一些基本特征抽象.

类的结构：1）成员变量：事物属性的描述；

2）方法:事物的行为；（可以做的事情）

3）构造方法：初始化对象；

4）内部类：即在类体中声明的类。

5）块：一段没有名称的代码块

Java类的定义

类的声明格式为:

[访问权限修饰符] [修饰符] class Car{

}

访问修饰符有两种public，无(默认default)

修饰符：final,abstract

关键字class用来定义一个类

Java类名的命名规范: 类名首字母大写,见名知意,驼峰表示

例如:

public class Car{ 

//成员变量定义 

String name; //名称 

String color; // 颜色 

float price;//价格 

}

声明成员变量的格式为：

[访问权限修饰符] [修饰符] type attr_name [=defaultValue] ;

成员变量是定义在类中，方法体之外的变量。

成员变量可以使用Java语言中任何一种数据类型（包括基本类型和引用类型）。

在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。

成员变量在创建对象的时候会从类中复制一份到对象中。

成员变量可以被类中方法、构造方法和特定类的语句块访问。

成员变量的作用范围为整个类体。

public class Car{ 

//成员变量定义 

String name; //名称 

String color; // 颜色 

float price;//价格 

方法声明格式为: 

[访问权限修饰符] [修饰符]/ void start(){ 

System.out.println("汽车启动"); 

[return 返回值;] 

} 

}

Java对象

对象：对象是类的一个实例，是以类为模板在内存中创建的实际存在的实例。

类汽车图纸, 对象实际存在的一辆汽车,拥有类中定义的功能,可以被使用。

对象的创建和使用

Car x1 = new Car();

Car x1:使用Car类作为类型声明一个变量x1.

new Car()**:使用new + Car类构造方法创建对象.

**= 😗*将右边创建的对象地址赋给左边的x1变量

使用x1变量访问对象中的成员变量和成员方法.

同一类的每个对象有不同的成员变量存储空间。

同一类的每个对象共享该类的方法。

类和对象

类和对象的关系：类是一类事物的抽象概念,是一个模型. 对象是由这个模型所创造的一个个具体存在的,实实在在存在的实例. 所以创建对象的过程也叫实例化对象

变量的分类

成员变量：
成员变量是定义在类中，方法体之外的变量。
成员变量可以使用Java语言中任何一种数据类型（包括基本类型和引用类型）。在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。成员变量在创建对象的时候会从类中复制一份到对象中。
成员变量可以被方法、构造方法和特定的语句块访问。
成员变量的作用范围为整个类体。

局部变量：
在方法、构造方法或者语句块中定义的变量被称为局部变量。
局部变量可以使用Java语言中任何一种数据类型（包括基本类型和引用类型）。局部变量
在使用前必须初始化赋值。
变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。

方法分类

成员方法：成员方法是定义在类中。
语法格式：
修饰符返回值类型方法名( 参数列表) {
方法体语句；
[return 返回值]
}

构造方法:用来初始化对象的方法

构造方法名与类名相同,且没有返回值,且不需要使用void修饰。
作用:在构造方法中为创建的对象初始化赋值,
在创建一个对象的时候，至少要调用一个构造方法。
每个类都有构造方法。如果没有显式地为类定义构造方法，Java将会为该类提供一个默认构造方法,但是只要在一个Java类中定义了一个构造方后，默认的无参构造方法即失效。
一个类可以有多个构造方法。
例： public class Car{
public Car(){ }
public Car(String name){ // 这个构造方法有一个参数：name }
}
例：创建Car类的对象
Car car1 = new Car();
Car car2 = new Car(“宝马”

方法重载

方法的重载是指同一个类中具有相同的名字，但参数不同的多个方法。

参数不同（可以有三方面的不同）
数量不同
类型不同
顺序不同
调用时，会根据不同的参数表选择对应的方法。
注意：方法重载跟方法的返回值类型没有任何关系

对象与引用

Java 语言中除基本类型之外的变量类型都称之为引用类型。

Java中的对象是通过引用对其操作的。

例如：我们有一个自定义类为Car（汽车类

class Car{
String color;
String name;
String model;
}
Car bm= new Car();
/*通常把这条语句的动作称之为创建一个对象，其实，它包含了三个动作。
这样写，就比较清楚了，有两个实体：一是对象引用变量，一是对象本身。
1）右边的“new Car()”，是以Car类为模板,在堆空间里创建一个Car类对象。
2）左边的“Car bm”创建了一个Car类型引用变量。所谓Car类的引用，就是以后可以用来指向Car
对象的对象引用。
3）”=”操作符使对象引用指向刚创建的那个Car对象。
我们可以把这条语句拆成两部分：
Car bm;
bm= new Car();
这样写，就比较清楚了，有两个实体：一是对象引用变量，一是对象本身
*/

new Car(); 这个语句在堆空间里创建了实体，尽管它们也是确确实实存在的实体，但是我们看不见，也摸不着。
对象没有名字，也就没法直接访问它。我们需要通过对象引用来间接访问对象。
对象好比是一只很大的气球，但是我们抓不住它。引用变量是一根绳，可以用来系汽球。
Car car1; （1）创建一根绳子，一根还没有系上任何一个汽球的绳；
Car car2;（2）就又做了一根绳，还没系上汽球，
car1 = new Car();（3）给car1 系上气球；
car2 = car1 ；（4）这里，发生了复制行为。要说明的是，对象本身并没有被复制，被复制的只是对象引用。
结果是，car2也指向了car1所指向的对象。两根绳系的是同一只汽球。

值传递与引用传递

Java中进行方法调用中传递参数时，参数传递有两种：
值传递：(形参数类型是基本数据类型)：方法调用时，实际参数把它的值传递给对应的形式参数，形式参数只是用实际参数的值初始化自己的存储单元内容，是两个不同的存储单元，所以方法执行中形式参数值的改变不影响实际参数的值。
引用传递：(形参数类型是引用数据类型参数)：也称为传地址。方法调用时，实际参数是对象，这时实际参数与形式参数指向同一个地址，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，这个结果在方法结束后被保留了下来，所以方法执行中形式参数的改变将会影响实际参数。
基本类型传递的是该数据值本身。引用类型传递的是对对象的引用，而不是对象本身。

static关键字

this关键字

this关键字代表当前对象
使用this关键字引用成员变量
使用this关键字引用成员方法

在一个类的方法或构造方法内部，可以使用“this.成员变量名”这样的
格式来引用成员变量名，常常用来区分同名的成员变量和局部变量。

public class Demo{
    private int a;
    public Demo(int a){
        this.a=a;
    }
    public int getA(){
        return a;
    }
    public xoid setA(int a){
        this.a=a;
    }
}

概念

static被称为静态，可以用来修饰类的属性,方法,代码块,内部类。

随着类的加载而加载，它有以下三个特点：
1）优先于对象存在
2）修饰的成员，被所有对象所共享
3）可不创建对象，直接被类调

static属性
静态属性是类的所有对象共享的，即不管创建了多少个对象，静态属性在内存中只有一个。
在这里插入图片描述

static方法可以使用对象调用，也可以直接用类名调用，建议用类名直接调用
在static方法内部只能访问类的static属性，不能访问类的非static性，static属性先加载

下面这个事例为：模拟卖票

public class TicketSeller{
private static int ticket=11;/ /票数只有一份 声明为静态的
public static void sellticket(){
ticket=ticket-1;
System.out.println("卖票的静态方法");
}
}
public class Test{
public static void main(String[] args) {
TicketSeller .sellticket();/ /没有创建对象也可以访问静态方法
}
}

代码块

代码块在类中声明，类似一个没有名称的方法体(代码块)，代码分实例块和静态块
实例块：每次创建对象时自动调用
{
//任何符合语法的Java代码
}
静态块：类加载时自动调用，仅一次，与是否创建对象无关。
static {
//任何符合语法的Java代码
}

类的加载执行

public class Test {
static int num;
int age;
static{
System.out.println("test static");
}
{
System.out.println("test");
}
public Test() {
System.out.println("test constructor");
}
//程序入口
public static void main(String[] args) {
new Test();
}

结果为：
test static
test
test constructor

包

概念：为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。

包的作用：
避免类重名
按照不同功能管理类
控制访问权先限

包（package）的命名规范：

在包名中，可以使用.号来区分包的级别；包名一般情况下是小写
第一级指该项目的类型，如com,org,gov等，
第二级指项目所开发或者运行的公司名称，如：oracle,sun,huawei等
第三级指项目的名称，如：bcms,oa,erp,cms等
第四级指项目模块的名称，如：bean,action,exception等

包可以更好得管理逻辑相关的类，可以控制不同包之间的访问权限

导入外部包的类，关键字“import“

访问权限修饰符

Java语言有四个权限访问修饰符，权限从大到小依次为：
1）public ：公共权限修饰类、属性、方法。可以被任意类访问
2）protected：受保护的权限修饰属性、方法。
可以被同包类访问，如果不是同包类，必须是该类的子类才可以访问。
3）default：同包权限修饰类、属性、方法。只能被同包的类访问
4）private：私有权限修饰属性、方法。只能在本类中
在这里插入图片描述

面向对象特征的三大特征

面向对象语言的三大特征：封装，继承，多态

封装

封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。
在这里插入图片描述
具体表现，使用不同的访问权限

public class Demo{
private String name;
public String getName (){
return name;
}
public void setName(String name){
this.name = name;
}
}

继承

继承：继承是面向对象程序设计不可缺少的设计思想，是实现代码可重
用的根基，是提高代码可扩展性的主要途径。

继承是从已有的类中派生出新的类，新的类能吸收已有类的属性和行为，
并能扩展新的能力。
在JAVA中使用extends关键字来表示继承关系。
JAVA不支持多继承，单继承使JAVA的继承关系很简单，一个类只能有一个
直接父类。
继承之后子类可以调用父类的所有非私有属性和非私有方法。

继承的形式：

[访问权限修饰符][修饰符] 子类名 extends 父类名{子类体}

public class Animal{
public void eat(){}
}
public class Dog extends Animal{
public void play(){}
}
子类对象可以直接调用父类的方法，强调复用性
Dog dog = new Dog ();
dog.eat();

名词：

Dog类是 Animal类的子类, Animal类是Dog类的父类
Dog类是 Animal类的派生类, Animal类是Dog类的基类

继承的传递性

C类从B类继承,B类又从A类继承，那么C类就具有B类和A类的所有非私有属性和非私有方法，当一个没有继承任何一个类时,jvm会默认让类继承Object类
Object是 java为所有类提供的基类

继承中的构造方法

子类构造方法会先调用父类构造方法
使用super关键字调用父类任意一个构造方法,必须写在构造方法的第一行
如果子类的构造方法中没有显式地调用基类构造方法，则系统默认调用基类无参数的构造方法。

super关键字用途
使用super关键字访问父类成员
用super.成员变量名来引用父类成员变量
用super.方法名（参数列表）访问父类的方法。
用super.构造方法(参数列表)访问父类构造方法
误区: 不要把super误认为是父类对象.在创建子类对象时,
不会创建父类对象. 只会将父类中的信息加载到子类对象中存储。

方法的重写(OverRide)
应用场景
当父类的方法实现不能满足子类需求时,可以对方法进行重写( override)
在子类中可以根据需要对从基类中继承来的方法进行重写。
方法重写规则
方法名相同、参数列表相同；
返回值类型相同；
访问权限不能小于父类权限;
注意：构造方法,静态方法不能重写,成员变量不存在重写。

多态

概念：同一种事物，在不同时刻表现不同的状太态

多态存在的三个必要条件
要有继承（包括接口的实现）(前提条件)
要有重写(前提条件)
父类引用指向子类对象

当编译期类型是父类，运行期类型是子类时，被称为父类引用指向子类对象

class Animal{ ……
}
class Cat extends Animal{ ……
}
class Dog extends Animal { ……
}
Animal x = new Cat() //Animal 的引用指向Cat的对象

多态环境下对成员方法的调用

class Animal{
void show() {
System.out.println(“Anmial");
}
}
class Cat extends Animal{
void show() {
System.out.println(“cat");
}
}……. Animal x = new Cat()
x.show() //调用的是子类中的方法
//简单的说：编译看左边，运行看右边。

多态环境下对静态成员方法的调用

class Animal{
static void show() {
System.out.println(“Animal");
}
}
class Cat extends Animal {
static void show() {
System.out.println(“Cat");
}
}……. Animal x = new Cat()
x.show() //调用的是动物类中的静态成员方法。
//简单的说：编译和运行都看左边。

多态环境下对成员变量的调用

class Animal{
int num = 3;
}
class Cat extends Animal {
int num = 4;
}……. Animal x = new Cat()
x.num; //调用的是动物类中的成员变量。
//简单的说：编译和运行都看等号左边。
//注意：变量不存在被子类覆写这一说法，只有方法存在覆写。

方法参数具有多态性

class Animal{
void eat() {}
}
class Cat extends Animal{
void eat() {}
}
class Dog extends Animal{
void eat(){}
}
//方法的形式参数类型是父类类型，而传递的实际参数可以是任意
子类的对象
method(Animal animal){
animal .eat();
}
//方法参数多态性的好处：提高代码的扩展性

向上转型

class Animal{
void eat(){ }
}
class Cat extends Animal{
void look() {
System.out.println("看家");
}
} ………
Animal x=new Cat() //向上造型，Cat对象提升到Animal对象
x.eat() //只能使用父类中的方法
x.look() //报错！不能使用子类中的方法
//向上转型的作用是：提高程序的扩展性。

向下转型

class Animal{
void eat(){ }
}
class Cat extendsAnimal{
void look() {
System.out.println("看家");
}
} ………
Animal x=new Cat()
Cat m=(Cat)x; //向下转型
m.eat() ;
m.look();//子父类中的方法都可以使用
//向下转型的作用是：为了使用子类中的特有方法。

抽象类

抽象方法：一种特殊的方法：它只有声明，而没有具体的实现.

抽象方法必须用abstract关键字进行修饰。
如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法。
用abstract修饰的类就是抽象类。如果某个类中包含有抽象方法，那么该类就必须定义成抽象类。
特点:
抽象类不能被实例化，但可以有构造方法,因为抽象类中含有无具体实现的方法，所以不能用抽象类创建对象。
抽象类只能用作基类，表示的是一种继承关系。继承抽象类的非抽象类必须实现其中的所有抽象方法，而已实现方法的参数、返回值要和抽象类中的方法一样。否则，该类也必须声明为抽象类。
使用关键字abstract定义抽象类，一般语法：
在这里插入图片描述
抽象类，抽象方法，在软件开发过程中都是设计层面的概念。也就是说，

设计人员会设计出抽象类，抽象方法，程序员都是来继承这些抽象类并

覆盖抽象方法，实现具体功能。

final关键字

final 用于声明属性，方法和类。
属性:定义就必须直接赋值或者在构造方法中进行赋值，并且后期都不能
修改。
方法:子类里不可以重写。
类:不能被定义为抽象类或是接口,不可被继承。

private int index;//final属性赋值
private static final double pai=3.14;
private final int level;//在声明时同时赋值，往往与static 一起使用。
public Test(){
level=0;
}//声明时不赋值，必须在构造方法中
逐一赋值。
public Test(int index){
this.index=index;
level=1;
}
//总的原则：保证创建每一个对象的时候，final属性的值是确定的。

对参数做final修饰。
在方法参数前面加final关键字，为了防止数据在方法体中被修改
在这里插入图片描述

接口

概念：可以使用Java接口来实现
在这里插入图片描述
面向接口编程

简单认识一下接口

public interface MyInterface {
int num = 10;//所有属性默认为: public static fina
public void foo()；//抽象方法是：public abstrac
public static void test(){
}
public default void test1(){
}

接口的定义和使用

接口的定义：使用 interface 关键字用来声明一个接口。
[访问修饰符] interface 接口名称 [extends 其他的接口名1,….其他的接口名n]
{
// 声明常量抽象方法静态方法默认方法
}

接口的使用：类使用implements关键字实现接口。在类声明中，Implements关
键字放在class声明后面。
[访问修饰符] class 类名 implements 接口名1，接口名2……{ }
结合继承：
[访问修饰符] class 类名 extends 父类名 implements 接口名1，接口名2……{ }

接口的特性

接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字
接口中方法可以是抽象的,静态的,默认的
接口中声明的属性默认为 public static final 的
接口不是被类继承了，而是要被类实现
接口不能实例化对象
与继承关系类似，接口与实现类之间存在多态性
一个接口能继承其它多个接口
当类实现接口的时候，类要实现接口中所有的抽象方法。否则，类必须
tatic fina
public void foo()；//抽象方法是：public abstrac
public static void test(){
}
public default void test1(){
}


#### 接口的定义和使用

接口的定义：使用 interface 关键字用来声明一个接口。
[访问修饰符] interface 接口名称 [extends 其他的接口名1,….其他的接口名n]
{
// 声明常量 抽象方法 静态方法 默认方法
}

接口的使用：类使用implements关键字实现接口。在类声明中，Implements关
键字放在class声明后面。
[访问修饰符] class 类名 implements 接口名1，接口名2……{ }
结合继承：
[访问修饰符] class 类名 extends 父类名 implements 接口名1，接口名2……{ }

#### 接口的特性

接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字
接口中方法可以是抽象的,静态的,默认的
接口中声明的属性默认为 public static final 的
接口不是被类继承了，而是要被类实现
接口不能实例化对象
与继承关系类似，接口与实现类之间存在多态性
一个接口能继承其它多个接口
当类实现接口的时候，类要实现接口中所有的抽象方法。否则，类必须
声明为抽象的类