学习java基础——面向对象_java中,如果类的成员变量是实例化的,那么通过这个类创造的多个对象能共享这个-CSDN博客

本文链接：https://blog.csdn.net/m0_37604110/article/details/102668823

文章目录

一.类对对象

1.1面向对象与面向过程

1.面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。
2.面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

举例对比：人把大象装进冰箱。

1.2面向对象中两个重要的概念

类：对一类事物的描述，是抽象的、概念上的定义
对象：是实际存在的该类事物的每个个体，因而也称为实例(instance)

二者的关系：
对象，是由类new出来的，派生出来的。

1.3对象的创建与对象的内存解析

典型代码：
Person p1 = new Person();
Person p2 = new Person();
Person p3 = p1;//没有新创建一个对象，共用一个堆空间中的对象实体。

说明：
如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）
意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。

对象内存解析图：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WuZ2mZbg-1571651839341)(C:\Users\yx20180503\AppData\Roaming\Typora\typora-user-images\1571643644321.png)]$

对象数组内存图

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5lr0StmU-1571651839342)(C:\Users\yx20180503\AppData\Roaming\Typora\typora-user-images\1571643736511.png)]$

1.4 匿名对象

我们创建的对象，没显式的赋给一个变量名。即为匿名对象

特点：匿名对象只能调用一次。
举例：

new Phone().sendEmail();
new Phone().playGame();
new Phone().price = 1999;
new Phone().showPrice();//0.0	

//应用场景：
PhoneMall mall = new PhoneMall();
//匿名对象的使用
mall.show(new Phone());
class PhoneMall{
	public void show(Phone phone){
		phone.sendEmail();
		phone.playGame();
	}
}

1.5.理解"万事万物皆对象"

二、类的结构之一：属性

对比：属性 vs 局部变量

2.1相同点：

定义变量的格式：数据类型变量名 = 变量值
先声明，后使用
变量都其对应的作用域

2.2 不同点：

2.2.1在类中声明的位置的不同

属性：直接定义在类的一对{}内
局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量

2.2.2 关于权限修饰符的不同

属性：可以在声明属性时，指明其权限，使用权限修饰符。
常用的权限修饰符：private、public、缺省、protected —>封装性
目前，大家声明属性时，都使用缺省就可以了。
局部变量：不可以使用权限修饰符。

2.2.3 默认初始化值的情况：

属性：类的属性，根据其类型，都默认初始化值。
整型（byte、short、int、long：0）

浮点型（float、double：0.0）

字符型（char：0 （或’\u0000’））

布尔型（boolean：false）

引用数据类型（类、数组、接口：null）
局部变量：没默认初始化值。

意味着，我们在调用局部变量之前，一定要显式赋值。

特别地：形参在调用时，我们赋值即可。

2.2.4 在内存中加载的位置：

属性：加载到堆空间中（非static）
局部变量：加载到栈空间

在这里插入图片描述

三、类的结构之二：方法

3.1 方法的声明

权限修饰符返回值类型方法名(形参列表){

方法体

}

说明：

Java规定的4种权限修饰符：private、public、缺省、protected
返回值类型：返回值 vs 没返回值
- 如果方法返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用return关键字来返回指定类型的变量或常量：“return 数据”。
- 如果方法没返回值，则方法声明时，使用void来表示。通常，没返回值的方法中，就不需要使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。

3.3 方法的重载的概念

3.3.1 定义：

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

3.3.2 总结：

“两同一不同”:

同一个类、相同方法名
参数列表不同：参数个数不同，参数类型不同
跟方法的权限修饰符、返回值类型、形参变量名、方法体都没关系！

3.3 可变个数形参的方法

3.3.1使用说明

可变个数形参的格式：数据类型 … 变量名
当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。
可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
可变个数形参在方法的形参中，必须声明在末尾
可变个数形参在方法的形参中,最多只能声明一个可变形参。

3.4java的值传递机制

java中参数传递机制：值传递
【例题1】
在这里插入图片描述
【例题2】

四类的结构之三：构造器

1.构造器的作用：

创建对象
.初始化对象的信息

2.使用说明：

如果没显式的定义类的构造器的话，则系统默认提供一个空参的构造器
.定义构造器的格式：权限修饰符类名(形参列表){}
一个类中定义的多个构造器，彼此构成重载
一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
一个类中，至少会有一个构造器。

五面向对象的特征一：封装性

1. 为什么要引入封装性？

我们程序设计追求“高内聚，低耦合”。
高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
低耦合：仅对外暴露少量的方法用于使用。

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

2封装性思想具体的代码体现：

体现一：将类的属性xxx私化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值

体现二：不对外暴露的私有的方法

体现三：单例模式（将构造器私有化）

体现四：如果不希望类在包外被调用，可以将类设置为缺省的。

3 Java规定的四种权限修饰符

权限从小到大顺序为：private < 缺省 < protected < public
具体的修饰范围：
四种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
修饰类的话，只能使用：缺省、public

六关键字：this,super,static,final,abstract,interface

6.1 this

this理解为：当前对象或当前正在创建的对象

1怎么使用

可以调用的结构：属性、方法；构造器
在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。但是，

通常情况下，我们都择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式

的使用"this.变量"的方式，表明此变量是属性，而非形参。
在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用当前正在创建的对象属性或方法。但是，通常情况下，我们都择省略"this."。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。

2. this调用构造器：

我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器
构造器中不能通过"this(形参列表)"方式调用自己
如果一个类中有n个构造器，则最多有 n - 1构造器中使用了"this(形参列表)"
规定："this(形参列表)"必须声明在当前构造器的首行
构造器内部，最多只能声明一个"this(形参列表)"，用来调用其他的构造器

6.2 super

super 关键字可以理解为：父类的

6.2.1怎么使用

可以用来调用的结构：属性、方法、构造器
super调用属性、方法：

我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."
特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性。
特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。

6.2.2 super调用构造器：

我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器
"super(形参列表)"的使用，必须声明在子类构造器的首行！
我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能二一，不能同时出现
在构造器的首行，没显式的声明"this(形参列表)“或"super(形参列表)”，则默认调用的是父类中空参的构造器：super()
在类的多个构造器中，至少一个类的构造器中使用了"super(形参列表)"，调用父类中的构造器

6.3 static

可以用来修饰的结构：主要用来修饰类的内部结构,属性、方法、代码块、内部类

1.static修饰属性(静态变量（或类变量）

属性，是否使用static修饰，又分为：静态属性 vs 非静态属性(实例变量)

实例变量：我们创建了类的多个对象，每个对象都独立的拥一套类中的非静态属性。当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。
静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。

static修饰属性的其他说明：
1. 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
2. 静态变量的加载要早于对象的创建。
3. 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。

2.静态变量内存解析：

在这里插入图片描述

3.static修饰方法：静态方法、类方法

随着类的加载而加载，可以通过"类.静态方法"的方式进行调用

静态方法中，只能调用静态的方法或属性
非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性

4.static的注意点

在静态的方法内，不能使用this关键字、super关键字
关于静态属性和静态方法的使用，大家都从生命周期的角度去理解。

6.4 final

static final 用来修饰属性：全局常量

final：最终的，可以用来修饰：类、方法、变量

final 用来修饰一个类:此类不能被其他类所继承。
用来修饰方法：表明此方法不可以被重写
用来修饰变量：此时的"变量"就称为是一个常量
- final修饰属性：可以考虑赋值的位置：显式初始化、代码块中初始化、构造器中初始化
- final修饰局部变量：尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。

6.5abstract

1.是什么？

abstract修饰类：抽象类

此类不能实例化
抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）

abstract修饰方法：抽象方法

抽象方法只方法的声明，没方法体
包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。
若子类重写了父类中的所的抽象方法后，此子类方可实例化

若子类没重写父类中的所的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰

2. 怎么用？

可以用来修饰：类、方法

3.注意点

abstract不能用来修饰：属性、构造器等结构
abstract不能用来修饰私方法、静态方法、final的方法、final的类

6.6 interface

1.使用说明

接口使用interface来定义

JDK7及以前：只能定义全局常量和抽象方法

全局常量：public static final的.但是书写时，可以省略不写
抽象方法：public abstract的

JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法

接口中不能定义构造器的！意味着接口不可以实例化
Java开发中，接口通过让类去实现(implements)的方式来使用.

如果实现类覆盖了接口中的所抽象方法，则此实现类就可以实例化

如果实现类没覆盖接口中所的抽象方法，则此实现类仍为一个抽象类
Java类可以实现多个接口 —>弥补了Java单继承性的局限性
接口与接口之间可以继承，而且可以多继承
接口的具体使用，体现多态性

2. Java8中关于接口的新规范

接口中定义的静态方法，只能通过接口来调用。
通过实现类的对象，可以调用接口中的默认方法。
如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法
如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的默认方法，那么子类在没重写此方法的情况下，默认调用的是父类中的同名同参数的方法。–>类优先原则
如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，
那么在实现类没重写此方法的情况下，报错。–>接口冲突。
这就需要我们必须在实现类中重写此方法
如何在子类(或实现类)的方法中调用父类、接口中被重写的方法

public void myMethod(){
		method3();//调用自己定义的重写的方法
		super.method3();//调用的是父类中声明的
		//调用接口中的默认方法
		CompareA.super.method3();
		CompareB.super.method3();
	}

3. 体会面向接口编程的思想

面向接口编程：我们在应用程序中，调用的结构都是JDBC中定义的接口，不会出现具体某一个
数据库厂商的API。

4.面试题

抽象类和接口的异同？
相同点：不能实例化；都可以包含抽象方法的。
不同点：

把抽象类和接口(java7,java8,java9)的定义、内部结构解释说明
类：单继承性接口：多继承
类与接口：多实现

七面向对象的特征二：继承性

1.为什么要有类的继承性？(继承性的好处）

减少了代码的冗余，提高了代码的复用性
便于功能的扩展
为之后多态性的使用，提供了前提

2.继承性的格式：

class A extends B{}

A:子类、派生类、subclass
B:父类、超类、基类、superclass

3.子类继承父类以后有哪些不同？

体现：一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的属性和方法。

特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私的结构。只因为封装性的影响，使得子类不能直接调用父类的结构而已。
子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展。

4 Java中继承性的说明

一个类可以被多个子类继承。
Java中类的单继承性：一个类只能有一个父类
子父类是相对的概念。
子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类
子类继承父类以后，就获取了直接父类以及所间接父类中声明的属性和方法

八、方法的重写

1.什么是方法的重写(override 或 overwrite)？

子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作

2.应用

重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。

3.重写的规则

方法的声明：权限修饰符返回值类型方法名(形参列表) throws 异常的{//方法体}

约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法

子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符
特殊情况：子类不能重写父类中声明为private权限的方法
返回值类型：
- 父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void
- 父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类
- 父类被重写的方法的返回值类型是基本数据类型(比如：double)，则子类重写的方法的返回值类型必须是相同的基本数据类型(必须也是double)
子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型

子类和父类中的同名同参数的方法要么都声明为非static的（考虑重写，要么都声明为static的（不是重写）

4.面试题区分方法的重写和重载？

二者的概念
重载和重写的具体规则
重载：不表现为多态性。
重写：表现为多态性。

重载，是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不同的参数表，对同名方的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。它们的调用地址在编译期就绑定了。Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法。所以：对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定”；

而对于多态，只等到方法调用的那一刻，解释运行器才会确定所要调用的具体方法，这称为“晚绑定”或“动态绑定”。

引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚绑定，它就不是多态。”

九、面向对象的特征三：多态性

1.多态性的理解

可以理解为一个事物的多种形态。

2.何为多态性

父类的引用指向子类的对象（或子类的对象赋给父类的引用）

举例：

Person p = new Man();
Object obj = new Date();

3.多态性的使用：虚拟方法调用

有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。

总结：编译，看左边；运行，看右边。

4.多态性的使用前提

1.类的继承关系

2.方法的重写

5.多态性使用的注意点：

对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）

十.内部类

定义：Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类

1.内部类的分类：

成员内部类（静态、非静态） vs 局部内部类(方法内、代码块内、构造器内)

2.成员内部类的理解

一方面，作为外部类的成员：

调用外部类的结构
可以被static修饰
可以被4种不同的权限修饰

另一方面，作为一个类：

类内可以定义属性、方法、构造器等
可以被final修饰，表示此类不能被继承。言外之意，不使用final，就可以被继承
可以被abstract修饰

3.成员内部类

3.1如何创建成员内部类的对象？(静态的，非静态的)

//创建静态的Dog内部类的实例(静态的成员内部类):
Person.Dog dog = new Person.Dog();

//创建非静态的Bird内部类的实例(非静态的成员内部类):
//Person.Bird bird = new Person.Bird();//错误的
Person p = new Person();
Person.Bird bird = p.new Bird();

3.2如何在成员内部类中调用外部类的结构？

class Person{
	String name = "小明";
public void eat(){
}
//非静态成员内部类
	class Bird{
		String name = "杜鹃";
		public void display(String name){
			System.out.println(name);//方法的形参
			System.out.println(this.name);//内部类的属性
			System.out.println(Person.this.name);//外部类的属性
		//Person.this.eat();
		}
	}
}