java面向对象学习笔记

面向对象基础

面向对象思想

三大思想

• 面向对象思想从概念上讲分为以下三种：OOA、OOD、OOP
  • OOA：面向对象分析（Object Oriented Analysis）
  • OOD：面向对象设计（Object Oriented Design）
  • OOP：面向对象程序（Object Oriented Programming

三大特征

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

创建对象内存分析

栈

• Java栈的区域很小 , 大概2m左右 , 特点是存取的速度特别快。
• 栈存储的特点是, 先进后出。
• 存储速度快的原因: 栈内存, 通过 ‘栈指针’ 来创建空间与释放空间 ! 指针向下移动, 会创建新的内存, 向上移动, 会释放这些内存 ! 这种方式速度特别快 , 仅次于PC寄存器 ! 但是这种移动的方式, 必须要明确移动的大小与范围 , 明确大小与范围是为了方便指针的移动 , 这是一个对于数据存储的限制, 存储的数据大小是固定的 , 影响了程序 的灵活性 ~ 所以我们把更大部分的数据 存储到了堆内存中 。
• 存储的是: 基本数据类型的数据 以及 引用数据类型的引用! 例如: int a =10; Person p = new Person(); 10存储在栈内存中 , 第二句代码创建的对象的引用p存在栈内存中。

堆

• 存放的是类的对象 。
• Java是一个纯面向对象语言, 限制了对象的创建方式: 所有类的对象都是通过new关键字创建 new关键字, 是指告诉JVM , 需要明确的去创建一个新的对象 , 去开辟一块新的堆内存空间: 堆内存与栈内存不同, 优点在于我们创建对象时 , 不必关注堆内存中需要开辟多少存储空间 , 也不需要关注内存占用时长 !
• 堆内存中内存的释放是由GC(垃圾回收器)完成的 。
• 垃圾回收器 回收堆内存的规则: 当栈内存中不存在此对象的引用时,则视其为垃圾 , 等待垃圾回收器回收 !

方法区

• 存放的是
  • 类信息
  • 静态的变量
  • 常量
  • 成员方法

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

寄存器

PC寄存器保存的是当前正在执行的JVM指令的地址 ! 在Java程序中, 每个线程启动时, 都会创建一个PC寄存器 !

本地方法栈

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

方法的重载

• 方法名称相同, 参数类型或参数长度不同, 可以完成方法的重载 !
• 方法的重载与返回值无关!
• 方法的重载 ,可以让我们在不同的需求下, 通过传递不同的参数调用方法来完成具体的功能。

匿名对象

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

面向对象进阶

this

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

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

static

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

代码块

• 普通代码块 在执行的流程中 出现的 代码块， 我们称其为普通代码块。
• 构造代码块 在类中的成员代码块， 我们称其为构造代码块， 在每次对象创建时执行， 执行在构造方法之前。
• 静态代码块 在类中使用static修饰的成员代码块， 我们称其为静态代码块， 在类加载时执行。 每次程序启动到关闭 ，只会 执行一次的代码块

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

包

• 包中java文件的定义： 在.java文件的首部， 必须编写类所属哪个包， 格式： package 包名;
• 包的定义： 通常由多个单词组成， 所有单词的字母小写， 单词与单词之间使用.隔开 ，一般命名为“com.公司名.项目 名.模块名…”。
• 规范由来： 由于Java面向对象的特性，每名Java开发人员都可以编写属于自己的Java Package，为了保障每个Java Package命名的唯一性，在最新的Java编程规范中，要求开发人员在自己定义的包名前加上唯一的前缀。由于互联网上 的域名称是不会重复的，所以多数开发人员采用自己公司在互联网上的域名称作为自己程序包的唯一前缀。例如： com.java.xxx

权限修饰符

单例

单例设计模式：保证程序在内存中只有一个对象存在（被程序所共享) 单例设计模式的两种实现方式： 
一、懒汉式：随着类的加载在内存中对象为null，当调用 getInstance 方法时才创建对象（延迟加载） 
二、饿汉式：随着类的加载直接创建对象（推荐开发中使用） 
单例设计模式的实现步骤： 
1．保证一个类只有一个实例，实现方式：构造方法私有化 
2．必须要自己创建这个实例，实现方式：在本类中维护一个本类对象（私有，静态） 
3．必须向整个程序提供这个实例，实现方式：对外提供公共的访问方式（getInstance方法，静态） 
懒汉式实现如下： 
class Single{ 
	private Single(){} 
	private static Single s1 = null; 
	public static Single getInstance(){ 
		if(s1 == null){
		 	s1 = new Single(); 
		}
		return s1; 
	} 
}
饿汉式实现如下： 
class Single2{ 
	private Single2(){} 
	private static Single2 s = new Single2(); 
	public static Single getInstance(){ return s; }
	void print(){ 
		System.out.println("Hello World!"); 
	} 
}

面向对象高级

抽象类

• 抽象类必须使用abstract class声明 一个抽象类中可以没有抽象方法。抽象方法必须写在抽象类或者接口中。

不能被实例化

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

• 抽象类本身是不能直接进行实例化操作的，即：不能直接使用关键字new完成。
• 一个抽象类必须被子类所继承，被继承的子类（如果不是抽象类）则必须覆写(重写)抽象类中的全部抽象方法。

常见问题

1、 抽象类能否使用final声明？
不能，因为final属修饰的类是不能有子类的 ， 而抽象类必须有子类才有意义，所以不能。
2、 抽象类能否有构造方法？
能有构造方法，而且子类对象实例化的时候的流程与普通类的继承是一样的，都是要先调用父类中的构造方法（默 认是无参的），之后再调用子类自己的构造方法。

抽象类和普通类的区别

1、抽象类必须用public或protected修饰(如果为private修饰，那么子类则无法继承，也就无法实现其抽象方法）。 默认缺省为 public
2、抽象类不可以使用new关键字创建对象， 但是在子类创建对象时， 抽象父类也会被JVM实例化。
3、如果一个子类继承抽象类，那么必须实现其所有的抽象方法。如果有未实现的抽象方法，那么子类也必须定义为 abstract类

接口

接口的继承

接口因为都是抽象部分， 不存在具体的实现， 所以允许多继承,例如：
 interface C extends A,B{ }

接口和抽象类的区别

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

instanceof

• 作用：判断某个对象是否是指定类的实例，则可以使用instanceof关键字
• 格式：实例化对象 instanceof 类 //此操作返回boolean类型的数据

内部类

概念

在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。 广泛意义上的内部类一般来说包括这四种：
1、成员内部类
2、局部内部类
3、匿名内部类
4、静态内部类

成员内部类

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

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();

局部内部类

局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。 例如：
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修饰符的。

匿名内部类

匿名内部类由于没有名字，所以它的创建方式有点儿奇怪。创建格式如下： 
new 父类构造器（参数列表）|实现接口（） {
//匿名内部类的类体部分 
} 
在这里我们看到使用匿名内部类我们必须要继承一个父类或者实现一个接口，当然也仅能只继承一个父类或者实现一 个接口。
同时它也是没有class关键字，这是因为匿名内部类是直接使用new来生成一个对象的引用。当然这个引用是隐式的。

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

静态内部类

静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字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() { } 
	} 
}

包装类

装箱和拆箱操作

以下以Integer和Float为例进行操作将一个基本数据类型变为包装类，那么这样的操作称为装箱操作。
将一个包装类变为一个基本数据类型，这样的操作称为拆箱操作，因为所有的数值型的包装类都是Number的子类。

字符串转换

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

可变参数

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

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

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

递归