Java学习记录（面向对象）

面向对象基础

1. 面向对象思想

概述
面向对象(Object Oriented)是软件开发方法。面向对象的概念和应用已超越了程序设计和软件开发，是一种对现实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。

面向对象是相对于面向过程来讲的，指的是把 相关的数据和方法组织为一个整体 来看待，从更高的层次来进行系统建模，更贴近事物的自然运行模式。

面向过程到面向对象思想层面的转变：

面向过程关注的是执行的过程， 面向对象关注的是 具备功能的对象。面向对象到面向过程， 是程序员思想上 从执行者到指挥者的转变。

1.1 三大思想

面向对象思想从概念上讲分为以下三种：OOA、OOD、OOP

OOA：	面向对象分析（Object Oriented Analysis）
OOD：	面向对象设计（Object Oriented Design）
OOP：	面向对象程序（Object Oriented Programming

1.2 三大特征

封装性：所有的内容对外部不可见
继承性：将其他的功能继承下来继续发展
多态性：方法的重载本身就是一个多态性的体现

2 类与对象

关系

类表示一个共性的产物，是一个综合的特征，而对象，是一个个性的产物，是一个个体的特征。
类必须通过对象才可以使用，对象的所有操作都在类中定义。

类由属性和方法组成：
	· 属性：就相当于人的一个个的特征
	· 方法：就相当于人的一个个的行为，例如：说话、吃饭、唱歌、睡觉

类的定义格式

class 类名称{
	成员属性;
	成员方法;
}

类的使用规范

类必须编写在.java文件中

  一个（点）.java文件可以存在n个类，但只能有一个public修饰的类
 （点） .java文件的名称必须与public修饰的类名 完全一致

2.1 属性与方法

属性定义格式：

数据类型 属性名; 

属性定义并赋值的格式：

数据类型 属性名 = 初始化值; 

方法定义格式：

权限修饰符 返回值类型 方法名(形式参数列表){
	//方法体
	return 返回值；
}

2.2 对象的创建与使用

一个类要想真正的进行操作，则必须依靠对象，对象的定义格式如下:

类名称 对象名称 = new 类名称() ; 

如果要想访问类中的属性或方法（方法的定义），则可以依靠以下的语法形式：

访问类中的属性：	对象.属性 ;	
调用类中的方法：	对象.方法(实际参数列表) ;

对象的赋值格式：

对象名.属性名 = 值;

3 创建对象内存分析

3.1 栈

ava栈的区域很小 , 大概2m左右 , 特点是存取的速度特别快
栈存储的特点是, 先进后出

存储速度快的原因:

栈内存, 通过 '栈指针' 来创建空间与释放空间
指针向下移动, 会创建新的内存, 向上移动, 会释放这些内存
这种方式速度特别快 , 仅次于PC寄存器
但是这种移动的方式, 必须要明确移动的大小与范围

明确大小与范围是为了方便指针的移动 , 这是一个对于数据存储的限制, 存储的数据大小是固定的 ,影响了程序的灵活性

所以我们把更大部分的数据 存储到了堆内存中

存储的是:

基本数据类型的数据 以及 引用数据类型的引用
Example：
	int	a	=10;
	Person p = new Person(); 
10存储在栈内存中 ,	第二句代码创建的对象的引用(p)存在栈内存中

3.2 堆

存放的是类的对象 .

Java是一个纯面向对象语言, 限制了对象的创建方式:

所有类的对象都是通过new关键字创建

new关键字, 是指告诉JVM , 需要明确的去创建一个新的对象 , 去开辟一块新的堆内存空间:

堆内存与栈内存不同, 优点在于我们创建对象时 , 不必关注堆内存中需要开辟多少存储空间 , 也不需要关注内存占用时长

堆内存中内存的释放是由GC(垃圾回收器)完成的

垃圾回收器 回收堆内存的规则:

当栈内存中不存在此对象的引用时,则视其为垃圾 , 等待垃圾回收器回收

Example：
	Person p0 = new Person(); 
	Person p1 = p0;
	Person p2 = new Person();

3.3 方法区

存放的是

- 类信息
- 静态的变量
- 常量
- 成员方法 

方法区中包含了一个特殊的区域 ( 常量池 )(存储的是使用static修饰的成员)

3.4 PC寄存器

PC寄存器保存的是 当前正在执行的 JVM指令的 地址

在Java程序中, 每个线程启动时, 都会创建一个PC寄存器

3.5 本地方法栈

保存本地(native)方法的地址

3.6 实例分析

4 构造方法（构造器）

概述

作用：

用于对象初始化。

执行时机：

在创建对象时,自动调用

特点：

所有的Java类中都会至少存在一个构造方法

如果一个类中没有明确的编写构造方法, 则编译器会自动生成一个无参的构造方法, 构造方法中没有任何的代码

如果自行编写了任意一个构造器, 则编译器不会再自动生成无参的构造方法。

4.1 定义格式

定义的格式:

与普通方法基本相同, 区别在于:	方法名称必须与类名相同, 没有返回值类型的声明

案例：

class Person {
		public Person() {
			System.out.println("对象创建时,此方法调用");
		}
	}

4.4 构造方法设计

建议自定义无参构造方法，不要对编译器形成依赖，避免错误发生。

当类中有非常量成员变量时，建议提供两个版本的构造方法，一个是无参构造方法，一个是全属性做参数的构 造方法。

当类中所有成员变量都是常量或者没有成员变量时，建议不提供任何版本的构造。

5，方法的重载

方法名称相同, 参数类型或参数长度不同, 可以完成方法的重载

方法的重载与返回值无关

方法的重载 ,可以让我们在不同的需求下, 通过传递不同的参数调用方法来完成具体的功能。、

Example：
	public void setInfo( int age, String name) {
			this.name = name;
			this.age = age;
		}
	public void setInfo(String name, int age) {
			this.name = name;
			this.age = age;
		}

6，构造方法的重载

一个类, 可以存在多个构造方法 :

参数列表的长度或类型不同即可完成构造方法的重载

构造方法的重载 ,可以让我们在不同的创建对象的需求下, 调用不同的方法来完成对象的初始化

Example：
	public Preson() {}
	public Preson(String name, int age) {
			this.name = name;
			this.age = age;
		}

7，匿名对象

没有对象名称的对象 就是匿名对象。

匿名对象只能使用一次，因为没有任何的对象引用，所以将称为垃圾，等待被GC回收。 只使用一次的对象可以通过匿名对象的方式完成。

面向对象进阶

1 封装private

我们观察如下代码：

class Person{ 
		String name ;	 // 表示姓名 
		int age ; 		// 表示年龄 
		void say(){ 
			System.out.println("姓名：" + name + "；年龄：" + age) ; 
		} 
	}
	public class Demo{ 
		public static void main(String args[]){ 
			Person per = new Person() ; 
			per.name = "张三" ; 
			per.age = -30 ; 
			per.say() ;
		} 
	}

以上的操作代码并没有出现了语法错误，但是出现了逻辑错误 （年龄-30岁）

在开发中， 为了避免出现逻辑错误， 我们建议对所有属性进行封装，并为其提供setter及getter方法进行设置和取得操作。

修改代码如下：

class Person{ 

	private String name ; // 表示姓名 
	private int age ; // 表示年龄 
	void tell(){ 
		System.out.println("姓名：" + getName() + "；年龄：" + getAge()) ; 
	}
	public void setName(String str){ 
		name = str ; 
	}
	public void setAge(int a){ 
		if(a>0&&a<150) 
			age = a ; 
	}
	public String getName(){ 
		return name ; 
	}
	public int getAge(){ 
		return age ; 
	} 
}
public class Demo{ 
	public static void main(String args[]){ 
		Person per = new Person() ;
		per.setName("张三") ; 
		per.setAge(-30) ; 
		per.tell() ; 
	} 
}

2 this

在Java基础中，this关键字是一个最重要的概念。使用this关键字可以完成以下的操作：

. 调用类中的属性 
· 调用类中的方法或构造方法 
· 表示当前对象 

3 static

概述
static表示“静态”的意思，可以用来修饰成员变量和成员方法
static的主要作用在于创建独立于具体对象的域变量或者方法

简单理解：

被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。

由于静态变量的存储空间并不在堆内存中，而是在方法区中开辟一块内存用于存储，所以静态变量不会因为对象的多次创建而在内存中建立多份数据

注意:

• 静态成员 在类加载时加载并初始化。
• 无论一个类存在多少个对象 , 静态的属性, 永远在内存中只有一份( 可以理解为所有对象公用 )
• 在访问时： 静态不能访问非静态 , 非静态可以访问静态

4 代码块

普通代码块

在执行的流程中 出现的 代码块， 我们称其为普通代码块。

构造代码块

在类中的成员代码块， 我们称其为构造代码块， 在每次对象创建时执行， 执行在构造方法之前。

静态代码块

在类中使用static修饰的成员代码块， 我们称其为静态代码块， 在类加载时执行。 每次程序启动到关闭 ，只会执行一次的代码块。

class Student{
	{
		//构造代码块，位于构造方法之前，在每次对象创建时执行， 执行在构造方法之前
	}
	static {
		//静态代码块， 在类加载时执行。 首次加载类时执行 ，只会执行一次的代码块。 
	}	
	
	public Student() {}	//构造方法
	
	{
		//普通代码块
	}
}

面试题：

构造方法 与 构造代码块 以及 静态代码块的执行顺序： 
静态代码块 --> 构造代码块 --> 构造方法

5 包

介绍

• 把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
• 包如同文件夹一样，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
• 包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类

5.1 包的限制使用

• 包中java文件的定义：

  在.java文件的首部， 必须编写类所属哪个包， 格式：

  package 包名;

• 包的定义：

  通常由多个单词组成， 所有单词的字母小写， 单词与单词之间使用.隔开 ，一般命名为“com.公司名.项目名.模块名…”。

5.2 import关键字

import 包名.类名;

导入其他包中的方法来使用

6 权限修饰符

权限修饰符\访问权限	类	包	子类	全部
public	v	v	v	v
protected	v	v	v	x
friendly（默认（default））	v	v	x	x
private	v	x	x	x

7 main方法详解

public static void main(String args[])

以上的各个参数的含义如下：
	· public：表示公共的内容，可以被所有操作所调用 
	· static：表示方法是静态的，可以由类名称直接调用。java StaticDemo09 
	· void：表示没有任何的返回值操作 
	· main：系统规定好的方法名称。如果main写错了或没有，会报错：NoSuchMethodError: main 
	· String[] args：字符串数组，接收参数的 

public class StaticDemo10{ 
	public static void main(String args[]){ 
		for(int i=0;i<args.length;i++){ 
			System.out.println(args[i]) ; 
		} 
	} 
}

所有的参数在执行类的时候以空格进行分割。

java StaticDemo10 1 2 3 4 5 6 7

但是，如果现在我要输入的是以下几种参数“hello world”、“hello vince”、“hello mjw”。

因为以空格分割，所以以上的三组参数会当做六组参数输入，那么此时如果要想完成有空格的内容输入，则参数需要使用“"”括起来。

java StaticDemo10 “hello world” “hello vince” “hello mjw”

面向对象高阶

1 抽象类

概念
抽象类必须使用 abstract class 声明

一个抽象类中可以没有抽象方法但抽象方法必须写在抽象类或者接口

格式：

abstract class 类名{ 
	// 抽象类 
} 

1.1 抽象方法

只声明而未实现的方法称为抽象方法 （未实现指的是：没有“{}”方法体），抽象方法必须使用abstract关键字声明。

格式：

abstract class 类名{ // 抽象类 
	public abstract void 方法名() ; // 抽象方法，只声明而未实现 
}

1.2 特点

在抽象类的使用中有几个原则：

• 抽象类本身是不能直接进行实例化操作的，即：不能直接使用关键字new完成。

• 一个抽象类必须被子类所继承，被继承的子类（如果不是抽象类）则 必须重写抽象类中的全部抽象方法

常见问题

1、 抽象类能否使用final声明？

• 不能，因为final属修饰的类是不能有子类的 ， 而抽象类必须有子类才有意义，所以不能。

2、 抽象类能否有构造方法？

• 能有构造方法，而且子类对象实例化的时候的流程与普通类的继承是一样的，都是要先调用父类中的构造方法（默认是无参的），之后再调用子类自己的构造方法

1.3 抽象类与普通类的区别

1、抽象类必须用public或protected修饰(如果为private修饰，那么子类则无法继承，也就无法实现其抽象方法）。默认缺省为 public

2、抽象类不可以使用new关键字创建对象， 但是在子类创建对象时， 抽象父类也会被JVM实例化。

3、如果一个子类继承抽象类，那么必须实现其所有的抽象方法。如果有未实现的抽象方法，那么子类也必须定义为abstract类

2 接口

概念

如果一个类中的全部方法都是抽象方法，全部属性都是全局常量，那么此时就可以将这个类定义成一个接口。

定义格式：

interface 接口名称{ 
	全局常量 ; 
	抽象方法 ; 
}

2.1 面向接口编程思想

这种思想是接口是定义（规范，约束）与实现（名实分离的原则）的分离。

优点：

1、 降低程序的耦合性 
2、 易于程序的扩展 
3、 有利于程序的维护 

2.2 全局常量和抽象方法的简写

因为接口本身都是由全局常量和抽象方法组成 ， 所以接口中的成员定义可以简写：

1、全局常量编写时， 可以省略public static final 关键字
	Example： 
		public static final String INFO = "内容" ; 
	简写后： 
	String INFO = "内容" ; 

2、抽象方法编写时， 可以省略 public abstract 关键字， 
	Example： 
		public abstract void print() ; 
	简写后：
	void print() ; 

2.3 接口的实现 implements

接口可以多实现：

格式：

class 子类 implements 父接口1,父接口2...{ 
} 

以上的代码称为接口的实现。那么如果一个类即要实现接口，又要继承抽象类的话，则按照以下的格式编写即可：

class 子类 extends 父类 implements 父接口1,父接口2...{ 
} 

2.4 接口的继承

接口因为都是抽象部分， 不存在具体的实现， 所以允许多继承

Example：
	interface C extends A,B{ 
	} 

注意

如果一个接口要想使用，必须依靠子类。 子类（如果不是抽象类的话）要实现接口中的所有抽象方法。

2.5 接口和抽象类的区别

• 抽象类要被子类继承，接口要被类实现。
• 接口只能声明抽象方法，抽象类中可以声明抽象方法，也可以写非抽象方法。
• 接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
• 抽象类使用继承来使用， 无法多继承。 接口使用实现来使用， 可以多实现
• 抽象类中可以包含static方法 ，但是接口中不允许（静态方法不能被子类重写，因此接口中不能声明静态方法）
• 接口不能有构造方法，但是抽象类可以有

3 多态

概念

多态：就是对象的多种表现形式，（多种体现形态）

3.1 多态的体现

对象的多态性，从概念上非常好理解，在类中有子类和父类之分，子类就是父类的一种形态 ，对象多态性就从此而来。

ps: 方法的重载 和 重写 也是多态的一种， 不过是方法的多态（相同方法名的多种形态）。

重载： 一个类中方法的多态性体现
重写： 子父类中方法的多态性体现。

3.2 多态的使用：对象的类型转换

类似于基本数据类型的转换：
向上转型：将子类实例变为父类实例

格式：父类 父类对象 = 子类实例 ；

向下转型：将父类实例变为子类实例

格式：子类 子类对象 = （子类）父类实例 ；	

4 instanceof关键字

作用：判断某个对象是否是指定类的实例，则可以使用instanceof关键字

格式：

实例化对象 instanceof 类 //此操作返回boolean类型的数据

5 Object类

概念

Object类是所有类的父类（基类），如果一个类没有明确的继承某一个具体的类，则将默认继承Object类。

例如我们定义一个类：

	public class Person{ 
	}

其实它被使用时 是这样的：

	public class Person extends Object{ 
	}

5.1 Object的多态

使用Object可以接收任意的引用数据类型

5.2 toString

建议重写Object中的toString方法。 此方法的作用：返回对象的字符串表示形式。
Object的toString方法， 返回对象的内存地址

package test;
public class test {
	public static void main(String[] args) {
	Preson p = new Preson();
	System.out.println(p);
	}
}
class Preson{
	
}

输出结果：
	test.Preson@15db9742

重写toString：
	class Preson{
		@Override
		public String toString() {
			return "个人信息  [姓名：" + name + ", 年龄：" + age + "]";
		}
	}

输出结果：
	个人信息  [姓名：null, 年龄：0]

5.3 equals

建议重写Object中的equals(Object obj)方法，此方法的作用：指示某个其他对象是否“等于”此对象。

Object的equals方法：实现了对象上最具区别的可能等价关系; 也就是说，对于任何非空引用值x和y ，当且仅当x和y引用同一对象（ x == y具有值true ）时，此方法返回true

equals方法重写时的五个特性：
自反性，对称性，传递性，一致性，非空性

• 自反性 ：对于任何非空的参考值x ， x.equals(x)应该返回true
• 对称性 ：对于任何非空引用值x和y ， x.equals(y)应该返回true当且仅当y.equals(x)回报true
• 传递性 ：对于任何非空引用值x ， y和z ，如果x.equals(y)回报true个y.equals(z)回报true ，然后x.equals(z)应该返回true
• 一致性 ：对于任何非空引用值x和y ，多次调用x.equals(y)始终返回true或始终返回false ，前提是未修改对象上的equals比较中使用的信息
• 非空性 ：对于任何非空的参考值x ， x.equals(null)应该返回false 。

6 内部类

概念

在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。

广泛意义上的内部类一般来说包括这四种： 
	1、成员内部类 
	2、局部内部类 
	3、匿名内部类 
	4、静态内部类

6.1 成员内部类

成员内部类是最普通的内部类，它的定义为位于另一个类的内部，形如下面的形式：

class Outer { 
	private double x = 0; 
	public Outer(double x) { 
		this.x = x; 
	}
	class Inner { //内部类 
		public void say() { 
			System.out.println("x="+x); 
		} 
	} 
}

特点： 成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）

注意： 当成员内部类拥有和外部类 同名的成员变量或者方法 时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。

如果要访问外部类的同名成员，需要以下面的形式进行访问：

外部类.this.成员变量 
外部类.this.成员方法 

外部使用成员内部类

Outter outter = new Outter(); 
Outter.Inner inner = outter.new Inner(); 

6.2 局部内部类

局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。

例如：

	class Person{ 
		public Person() { 
		} 
	}
	class Man{ 
		public Man(){ 
		}
		public People getPerson(){ 
			class Student extends People{ //局部内部类 
				int age =0; 
			}
			return new Student(); 
		} 
	} 

注意：
内部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。

6.3 匿名内部类

匿名内部类由于没有名字，所以它的创建方式有点儿奇怪。
创建格式如下：

new 父类构造器（参数列表）|实现接口（） 
{
//匿名内部类的类体部分 
} 

在这里我们看到使用匿名内部类我们必须要继承一个父类或者实现一个接口，当然也仅能只继承一个父类或者实现一个接口。同时它也是没有class关键字，这是因为匿名内部类是直接使用new来生成一个对象的引用。当然这个引用是隐式的。

注意：

• 使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或者实现一个接口。
• 匿名内部类中是不能定义构造函数的。
• 匿名内部类中不能存在任何的静态成员变量和静态方法。
• 匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。
• 匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。
• 只能访问final型的局部变量

6.4 静态内部类

静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。

静态内部类是不需要依赖于外部类对象的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法

格式：

public class Test { 

	public static void main(String[] args) { 

		Outter.Inner inner = new Outter.Inner(); 

	} 

}

class Outter {

public Outter() { 

}

static class Inner { 

	public Inner() { 

	} 

} 

}

7 包装类

概念

在Java中有一个设计的原则“一切皆对象”，那么这样一来Java中的一些基本的数据类型，就完全不符合于这种设计思想，因为Java中的八种基本数据类型并不是引用数据类型，所以Java中为了解决这样的问题，引入了八种基本数据类型的包装类。

序号	基本数据类型	包装类
1	int	Integer
2	char	Character
3	float	Float
4	double	Double
5	boolean	Boolean
6	byte	Byte
7	short	Short
8	long	Long

以上的八种包装类，可以将基本数据类型按照类的形式进行操作。

但是，以上的八种包装类也是分为两种大的类型的：
 
	Number：Integer、Short、Long、Double、Float、Byte都是Number的子类表示是一个数字。 
	Object：Character、Boolean都是Object的直接子类。 

7.1 装箱和拆箱操作

以下以Integer和Float为例进行操作

将一个基本数据类型变为包装类，那么这样的操作称为装箱操作。
将一个包装类变为一个基本数据类型，这样的操作称为拆箱操作， 

因为所有的数值型的包装类都是Number的子类，Number的类中定义了如下的操作方法，以下的全部方法都是进行拆箱的操作

序号	方法	描述
1	public byte byteValue()	用于Byte->byte
2	public abstract double doubleValue()	用于Double->double
3	public abstract float floatValue()	用于Float->float
4	public abstract int intValue()	用于Integer->int
5	public abstract long longValue()	用于Long->long
6	public short shortValue()	用于Short->short

装箱操作：

在JDK1.4之前 ，如果要想装箱，直接使用各个包装类的构造方法即可

Example
	int temp = 10 ; // 基本数据类型 
	Integer x = new Integer(temp) ; // 将基本数据类型变为包装类 

在JDK1.5，Java新增了自动装箱和自动拆箱，而且可以直接通过包装类进行四则运算和自增自建操作。

Example
	Float f = 10.3f ; // 自动装箱 
	float x = f ; // 自动拆箱 
	System.out.println(f * f) ; // 直接利用包装类完成 
	System.out.println(x * x) ; // 直接利用包装类完成 

7.2 字符串转换

使用包装类还有一个很优秀的地方在于：可以将一个字符串变为指定的基本数据类型，此点一般在接收输入数据上使用较多。

在Integer类中提供了以下的操作方法：

public static int parseInt(String s) ：将String变为int型数据 

在Float类中提供了以下的操作方法：

public static float parseFloat(String s) ：将String变为Float 

在Boolean 类中提供了以下操作方法：

public static boolean parseBoolean(String s) ：将String变为boolean 

8 可变参数

一个方法中定义完了参数，则在调用的时候必须传入与其一一对应的参数，但是在JDK 1.5之后提供了新的功能，可以根据需要自动传入任意个数的参数。

语法：

返回值类型 方法名称(数据类型…参数名称){ 
	//参数在方法内部 ， 以数组的形式来接收 
} 

注意：可变参数只能出现在参数列表的最后

9 递归

递归，在数学与计算机科学中，是指在方法的定义中使用方法自身。
也就是说，递归算法是一种直接或者间接调用自身方法的算法。

递归流程图如下：

本文地址：https://blog.csdn.net/Geraint_Tan/article/details/107243401