javaSE——类与对象
面向过程&面向对象
面向过程的思维模式（线性思维）
面向过程的思维模式是简单的线性思维，思考问题首先陷入第一步做什么、第二步做什么的细节中。这 种思维模式适合处理简单的事情，比如：上厕所。
面向对象的思维模式
面向对象的思维模式说白了就是分类思维模式。思考问题首先会解决问题需要哪些分类，然后对这些分 类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
显然，面向对象适合处理复杂的问题，适合处理需要多人协作的问题！
对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整 个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。
面向对象编程详解（OOP详解）
1、什么是面向对象
Java的编程语言是面向对象的，采用这种语言进行编程称为面向对象编程(Object-Oriented Programming, OOP)。
面向对象编程的本质就是：以类的方式组织代码，以对象的组织(封装)数据。
抽象(abstract)
忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了 解全部问题，而只是选择其中的一部分，暂时不用关注细节。
抽象是什么?就是将多个物体共同点归纳出来，就是抽出像的部分！
封装(Encapsulation)
封装是把过程和数据包围起来，对数据的访问只能通过指定的方式。
规定可见和隐藏，可以将应用程序修改带来的影响减少到最低限度。
继承(inheritance)
新类继承了原始类后,新类就继承了原始类的特性，新类称为原始类的派生类(子类)，而原始类称为新 类的基类(父类)。
派生类(子类)可以从它的基类(父类)那里继承方法和实例变量，并且派生类(子类)中可以修改或增加新的方法，解决了软件的可重用性问题。
多态(polymorphism)
多态性是指允许不同对象对同一消息作出响应。
多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。
相同类域的不同对象,调用相同方法,表现出不同的结果
从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。
从代码运行角度考虑是先有类后有对象。类是对象的模板。
2、类与对象的关系
类是一种抽象的数据类型,它是对某一类事物整体描述/定义,但是并不能代表某一个具体的事物.
例如: Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为
对象是抽象概念的具体实例
例如：张三就是人的一个具体实例,张三家里的旺财就是狗的一个具体实例。
Student s = new Student(1, "Tom", 20);
s.study();
Car c = new Car(1, "BWM", 500000);
c.run();
对象s就是Student类的一个实例,对象c就是Car类的一个具体实例,能够使用的是具体实例,而不是类。类只是给对象的创建提供了一个参考的模板而已.
但是在java中,没有类就没有对象,然而类又是根据具体的功能需求,进行实际的分析,最终抽象出来的
3、对象和引用的关系
引用 "指向" 对象 使用类类型、数组类型、接口类型声明出的变量,都可以指向对象,这种变量就是引用类型变量,简称引用。
在程序中,创建出对象后,直接使用并不方便,所以一般会用一个引用类型的变量去接收这个对象,这个就是 所说的引用指向对象.
方法回顾及加深
方法一定是定义在类中的,属于类的成员。
1、方法的定义
格式： 修饰符 返回类型 方法名(参数列表)异常抛出类型{...}
1. 修饰符
public、static、abstract、final等等都是修饰符，一个方法可以有多个修饰符。例如程序入口 main方法，就使用了public static这个俩个修饰符
注:如果一个方法或者属性有多个修饰符,这多个修饰符是没有先后顺序的
--多个修饰符没有先后顺序
2. 返回类型
方法执行完如果有要返回的数据,那么就要声明返回数据的类型,如果没有返回的数据,那么返回类型就必 须写void.
只有构造方法(构造器)不写任何返回类型也不写void
【示例】
package com.kuang.oop;
public class Demo01 {
public String sayHello() {
return "hello";
}
public int max(int a, int b) {
return a > b ? a : b;
}
public void print_enter(String msg) {
System.out.println(msg);
}
}
注：break和return的区别
return 语句的作用
(1) return 从当前的方法中退出,返回到该调用的方法的语句处,继续执行。
(2) return 返回一个值给调用该方法的语句，返回值的数据类型必须与方法的声明中的返回值的类型一 致。
(3) return后面也可以不带参数，不带参数就是返回空，其实主要目的就是用于想中断函数执行，返回调用函数处。
break语句的作用
(1)break在循环体内，强行结束循环的执行，也就是结束整个循环过程，不再判断执行循环的条件是否成立，直接转向循环语句下面的语句。
(2)当break出现在循环体中的switch语句体内时，其作用只是跳出该switch语句体。
3. 方法名
遵守java中标识符命名规则即可
4.参数列表
根据需求定义，方法可以是无参的，一个参数，或多个参数的
5.异常抛出类型
如果方法的代码在执行过程中，可能出现一些异常情况，那么就可以在方法上把这些异常声明并抛出，也可以同时声明抛出多个异常，用逗号隔开
public void readFile(String file)throws IOException{
}
public void readFile(String file)throws IOException,ClassNotFoundException{
}
2、方法调用
在类中定义了方法，这个方法中代码并不会执行，当这个方法被调用的时候，方法中的代码才会被一行一行顺序执行。
1.非静态方法
没有使用static修饰符修饰的方法,就是非静态方法.
调用这种方法的时候,是"一定"要使用对象的。因为非静态方法是属于对象的。(非静态属性也是一样的)
main方法
package com.kuang.oop;
public class Application {
//一个项目应该只存一个main方法,笔记里面写在一个框里是为了方便查看代码
public static void main(String[] args) {
Student stu = new Student();
stu.say();
}
}
package com.kuang.oop;
//没加static，非静态，需要声明对象来调用
public class Student {
public void say(){}
}
2. 静态方法
使用static修饰符修饰的方法,就是静态方法.
调用这种方法的时候,"可以"使用对象调用,也"可以"使用类来调用,但是推荐使用类进行调用,因为静态方法是属于类的。(静态属性也是一样的)
静态方法内不能直接访问到类中的非静态属性.
【例子】
package com.kuang.oop;
//静态，推荐使用类进行调用
public class Student {
public static void say() {
}
//一个项目应该只存一个main方法
public static void main(String[] args) {
Student.say();
}
}
3. 类中方法之间的调用
假设同一个类中有俩个方法,a方法和b方法，
（1）a和b都是非静态方法，相互之间可以直接调用。
public void a(){
b();
}
public void b(){
}
（2）a和b都是静态方法,相互之间可以直接调用。
public static void a(){
b();
}
public static void b(){
}
(3) a静态方法,b是非静态方法，a方法中不能直接调用b方法,但是b方法中可以直接调用a方法.
静态方法static 不能调用非静态方法！
public static void a(){
//b();报错
}
public void b(){
a();
}
另外：在同一个类中,静态方法内不能直接访问到类中的非静态属性.
总结：类中方法中的调用，两个方法都是静态或者非静态都可以互相调用，当一个方法是静态，一个方 法是非静态的时候，非静态方法可以调用静态方法，反之不能。
3、调用方法时的传参
1.形参和实参
-
参数列表中的a是方法test的形参(形式上的参数)
-
调用方法时的x是方法test的实参(实际上的参数)
【例子】
//a是形参，x是实参，调用时把x传给a
public void test(int a){
//..
}
main中内容
int x = 1;
t.test(x);
2. 值传递和引用传递
-
如果参数的类型是基本数据类型,那么就是值传递。
-
如果参数的类型是引用数据类型,那么就是引用传递。
-
值传递是实参把自己变量本身存的简单数值赋值给形参. 因此值传递对传入方法的形参进行改变不会影响实参大小。
-
引用传递是实参把自己变量本身存的对象内存地址值赋值给形参.引用传递中对形参的调节会改变实参的数值。
【示例：值传递】
package com.kuang.oop;
public class Test {
public static void can_it_changeNum(String[] args) {
int a = 10;
}
public static void main(String[] args) {
int a = 1;
System.out.println(a);//1
can_it_changeNum(args);
System.out.println(a);//1
}
}
【示例：引用传递】
package com.kuang.oop;
class Student {
String name;
}
public class Demo03 {
public static void changeName(Student s) {
//形参是引用类型
s.name = "tom";
}
public static void main(String[] args) {
Student s = new Student();
System.out.println(s.name);//null
changeName(s);
System.out.println(s.name);//tom
}
}
4、this关键字
1、this在类中的作用
【区别成员变量和局部变量】
package com.kuang.oop;
public class Student {
private String name;
public void setName(String name) {
// this.name表示类中的属性name
this.name = name;
}
}
【调用类中的其他方法】
package com.kuang.oop;
public class Student {
private String name;
public void setName(String name) {
// this.name表示类中的属性name
this.name = name;
}
public void print() {
//this.setName（）表示调用当前类中的setName方法
this.setName("tom");
}
}
注：默认情况下,setName("tom")和this.setName("tom")的效果是一样的.
【调用类中的其他构造器】
public class Student{
private String name;
public Student(){
//调用一个参数的构造器,并且参数的类型是String
this("tom");
}
public Student(String name){
this.name = name;
}
}
注:this的这种用法,只能在构造器中使用.普通的方法是不能用的.并且这局调用的代码只能出现在构造器中的第一句.
【示例】
public class Student{ private String name; //编译报错,因为this("tom")不是构造器中的第一句代码. public Student(){ System.out.println("hello"); this("tom"); } public Student(String name){ this.name = name; } }
2、this关键字在类中的意义
this在类中表示当前类 将来创建出的 对象。
【例子】
package com.kuang.oop;
public class Student {
private String name;
public Student() {
System.out.println("this =" + this);
}
public static void main(String[] args) {
//创建一个对象
Student s = new Student();
System.out.println("s =" + s);
}
}
结果：this =com.kuang.oop.Student@2a139a55
s =com.kuang.oop.Student@2a139a55
运行后看结果可知,this和s打印的结果是一样的,那么其实也就是：
- s是从对象的外部执行对象
- 而this是在对象的内部执行对象本身.
this.name和this.setName("tom")这俩句代码从本质上讲,和在对象外部使用变量s来调用是一样的,s.name和s.setName("tom")。
注：
s1对象中的this和s1相等,s2对象中的this和s2相等
因为类是模板,模板中写的this并不是只有一个,每个对象中都有一个属于自己的this,就像每个对象中都有一个属于自己的name属性一样.
创建与初始化对象
使用new关键字创建对象
使用new关键字创建的时候做的工作：
-
分配内存空间；
-
给 创建好的对象 进行默认的初始化 ；
-
以及对 类中构造器 的调用。
那么对main方法中的以下代码: Student s = new Student(); 1)为对象分配内存空间,将对象的实例变量自动初始化默认值为0/false/null。(实例变量的隐式赋值) 2)如果代码中实例变量有显式赋值,那么就将之前的默认值覆盖掉。(之后可以通过例子看到这个现象) 例如:显式赋值 private String name = "tom"; 3)调用构造器 4)把对象内存地址值赋值给变量。(=号赋值操作)
构造器
是c++中构造函数一样的存在
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:
-
必须和类的名字相同
-
必须没有返回类型,也不能写void、int，String等等的类型
构造器的作用：
- 使用new创建对象的时候必须使用类的构造器
- 构造器中的代码执行后，可以给对象中的属性初始化赋值
【对2的演示】
public class Student{
private String name;
public Student(){
name = "tom";
}
}
构造器的重载
除了无参构造器之外,很多时候我们还会使用有参构造器,在创建对象时候可以给属性赋值.
【例子】
//这里记得把name的private去掉，否则外部无法访问私有属性
package com.kuang.oop;
public class Student {
String name;
int age;
public Student() {
//name = "tom";//相当于没有显式指出name参数，就默认赋值为tom
//包含有参构造器时，其实不需要在默认构造器里方放语句了
}
//构造器带参数的重载
public Student(String name) {
this.name = name;
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
//构造时不传入参数
public static void main(String[] args) {
//创建一个对象
Student s = new Student();
System.out.println(s.name);//nul
//当然注释掉语句前得到默认构造为tom
}
//构造时传入参数
public static void main(String[] args) {
//创建一个对象
Student s = new Student("Leo");
System.out.println(s.name);//Leo
}
}
构造器之间的调用
使用this关键字,在一个构造器中可以调用另一个构造器的代码。
注意:this的这种用法不会产生新的对象,只是调用了构造器中的代码而已.一般情况下只有使用new关键 字才会创建新对象。
package com.kuang.oop;
public class Student {
String name;
int age;
public Student() {
}
public Student(String name) {
this.name = name;
}
public Student(String name, int age) {
//这句在没有创建对象的情况下，模仿方法间的调用
//相当于Student(name);
this(name);
this.age = age;
}
public static void main(String[] args) {
//创建一个对象
Student s = new Student("Leo", 15);//调用两个参数的构造器
System.out.println(s.name);//Leo
System.out.println(s.age);//15
}
}
默认构造器
在java中,即使我们在编写类的时候没有写构造器,那么在编译之后也会自动的添加一个无参构造器,这个 无参构造器也被称为默认的构造器。
但是,如果我们手动的编写了一个构造器,那么编译后就不会添加任何构造器了。
这就是为什么 我们定义一个有参构造后，想使用无参构造也需要定义无参构造 的原因，附【演示】
public class Student{
private String name;
//只手动定义了一个无参构造
public Student(String name){
this.name = name;
}
}
main:
//编译报错,因为没有无参构造器
Student s = new Student();
写在最后：
注意点：
- 定义有参构造之后，如果想使用无参构造，必须显式定义无参构造，否则无法使用
- 使用idea建立构造器有快捷键Alt + insert，但是vscode这样的编辑器是没有的
内存分析
JAVA程序运行的内存分析
栈 stack：
- 每个线程私有，不能实现线程间的共享！
- 局部变量放置于栈中。
- 栈是由系统自动分配，速度快！栈是一个连续的内存空间！
- 存放一些做引用的变量和一些基本变量类型
堆 heap：
- 放置new出来的对象！
- 堆是一个不连续的内存空间，分配灵活，速度慢！
方法区(也是堆)：
- 被所有线程共享！
- 用来存放程序中永远是不变或唯一的内容。（类代码信息、静态变量、字符串常量）
小结：这里只是了解基本的内存概念。类加载器、Class对象这些更加详细的内容，我们将在后面专门讲反射的课程里面讲。
引用类型的概念
- java中，除了基本数据类型之外的其他类型称之为引用类型。
- java中的对象是通过引用来操作的。(引用：reference)说白了，引用指的就是对象的地址！
属性（field，或者叫成员变量）
-
属性用于定义该类或该类对象包含的数据或者说静态属性。
-
属性作用范围是整个类体。
-
属性的默认初始化：在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。
(数值：0,0.0 char:u0000, boolean:false, 所有引用类型:null) -
属性定义格式：
[修饰符public\static] 属性类型 属性名 = [值（不填编译器赋予默认值）]
总结类与对象
- 类与对象
类是一个模板，是抽象的概念；对象是一个具体的实例
- 方法
熟知它的定义、调用！
- 对应的引用
引用类型： 除了 基本类型（8种） 之外的类型
对象是通过引用来操作的：栈（变量）---->堆（new）
- 属性：字段Field 成员变量
默认初始化：
- 数字：0 0.0
- char：u0000
- boolean: false
- 引用： null
用户自定义初始化：修饰符 属性类型 属性名 = 属性值
- 对象的创建和使用
- 必须使用new 关键字创造对象 Person p = new Person();
- 类里面有构造器
- 对象的属性 p.name
- 对象的方法 p..sleep()
类中只能包含这些：
静态的属性 属性
动态的行为 方法（包含伴生于类的构造器）
学习完类与对象终于认识到什么是类，什么是对象了。接下来要看的就是java的三大特征：继承、封装、多态。
