面向对象
一.面向对象的思想
面向对象(Object Oriented)是软件开发方法。面向对象的概念和应用已超越了程序设计和软件开发，是一种对现 实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。
面向对象是相对于面向过程来讲的,指的是把相关的数据和方法组织为一个整体 来看待,从更高的层次来进行系统建模，更贴近事物的自然运行模式。
面向过程到面向对象思想层面的转变:面向过程关注的是执行的过程，面向对象关注的是具备功能的对象。
面向对象思想从概念上讲分为以下三种：OOA、OOD、OOP
OOA：面向对象分析（Object Oriented Analysis）
OOD：面向对象设计（Object Oriented Design）
OOP：面向对象程序（Object Oriented Programming)
面向对象三大特性
封装性：所有的内容对外部不可见
继承性：将其他的功能继承下来继续发展
多态性：方法的重载本身就是一个多态性的体现
二.类和对象
类必须通过对象才可以使用，对象的所有操作都在类中定义。
类由属性和方法组成： ·
属性：就相当于人的一个个的特征 ·
方法：就相当于人的一个个的行为，例如：说话、吃饭、唱歌、睡觉
相当于一般-特殊的关系 类-对象
类的定义格式
class 类
{
成员属性;
成员方法;
方法定义格式： 权限修饰符 返回值类型 方法名(形式参数列表){
//方法体 return 返回值；
}
}
属性定义格式： 数据类型 属性名;
属性定义并赋值的格式： 数据类型 属性名 = 初始化值;
一个类要想真正的进行操作，则必须依靠对象，对象的定义格式如下:
类名称 对象名称 = new 类名称() ;
如果要想访问类中的属性或方法（方法的定义），则可以依靠以下的语法形式：
访问类中的属性： 对象.属性 ;
调用类中的方法： 对象.方法(实际参数列表) ;
三.构造器
Person p = new Person();
在右侧Person后面出现的小括号, 其实就是在调用构造方法 !
作用: 用于对象初始化。
执行时机: 在创建对象时,自动调用
特点:所有的Java类中都会至少存在一个构造方法
如果一个类中没有明确的编写构造方法, 则编译器会自动生 成一个无参的构造方法, 构造方法中没有任何的代码！
如果自行编写了任意一个构造器, 则编译器不会再自动生成无参的构造方法。
定义的格式: 与普通方法基本相同, 区别在于: 方法名称必须与类名相同, 没有返回值类型的声明 !
public class Demo3{
public static void main(String[] args){
Person p = new Person();
p = new Person();
p = new Person();
p = new Person();
}
}
class Person{
public Person(){
System.out.println("对象创建时,此方法调用");
}
}
构造方法分为有参和无参：
建议自定义无参构造方法，不要对编译器形成依赖，避免错误发生。 当类中有非常量成员变量时，建议提供两个版本的构造方法，一个是无参构造方法，一个是全属性做参数的构造方法。 当类中所有成员变量都是常量或者没有成员变量时，建议不提供任何版本的构造
重载构造方法
方法重载:方法名称相同, 参数类型或参数长度不同
构造方法的重载
一个类, 可以存在多个构造方法 : 参数列表的长度或类型不同即可完成构造方法的重载
四 getter setter
在开发中， 为了避免出现逻辑错误， 我们建议对所有属性进行封装，并为其提供setter及getter方法进行设置和取得 操作。
在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 ;
}
};
this
在Java基础中，this关键字是一个最重要的概念。使用this关键字可以完成以下的操作：
· 调用类中的属性 · 调用类中的方法或构造方法 · 表示当前对象
如this.age ||this.方法（）||this等等
static
static表示“静态”的意思，可以用来修饰成员变量和成员方法(后续还会学习 静态代码块 和 静态内部类)。
static的主要作用在于创建独立于具体对象的域变量或者方法
简单理解:被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访 问。 并且不会因为对象的多次创建 而在内存中建立多份数据
1.静态成员 在类加载时加载并初始化。
2. 无论一个类存在多少个对象 , 静态的属性, 永远在内存中只有一份( 可以理解为所有对象公用 )
3. 在访问时： 静态不能访问非静态 , 非静态可以访问静态 !
代码块
普通代码块 在执行的流程中 出现的 代码块， 我们称其为普通代码块。
构造代码块 在类中的成员代码块， 我们称其为构造代码块， 在每次对象创建时执行， 执行在构造方法之前。
静态代码块 在类中使用static修饰的成员代码块， 我们称其为静态代码块， 在类加载时执行。 每次程序启动到关闭 ，只会 执行一次的代码块。
五.包
1、把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
2、包如同文件夹一样，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名 加以区别。因此，包可以避免名字冲突。
3、包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。
包的定义： 通常由多个单词组成， 所有单词的字母小写，
单词与单词之间使用.隔开 ，一般命名为“com.公司名.项目 名.模块名…”。
六.抽象
抽象类必须使用abstract class声明 一个抽象类中可以没有抽象方法。
抽象方法必须写在抽象类或者接口中。
只声明而未实现的方法称为抽象方法（未实现指的是：没有“{}”方法体），抽象方法必须使用abstract关键字声明
原则：
在抽象类的使用中有几个原则：
· 抽象类本身是不能直接进行实例化操作的，即：不能直接使用关键字new完成。
· 一个抽象类必须被子类所继承，被继承的子类（如果不是抽象类）则必须覆写(重写)抽象类中的全 部抽象方法。
常见问题
1、 抽象类能否使用final声明？ 不能，因为final属修饰的类是不能有子类的 ， 而抽象类必须有子类才有意义，所以不能。
2、 抽象类能否有构造方法？ 能有构造方法，而且子类对象实例化的时候的流程与普通类的继承是一样的，都是要先调用父类中的 构造方法（默认是无参的），之后再调用子类自己的构造方法。
格式
abstract class 类名
{
public abstract void 方法名();
}
抽象类与普通类的区别
1、抽象类必须用public或procted 修饰(如果为private修饰，那么子类则无法继承，也就无法实现其 抽象方法）。默认缺省为 public
2、抽象类不可以使用new关键字创建对象， 但是在子类创建对象时， 抽象父类也会被JVM实例化。 3、如果一个子类继承抽象类，那么必须实现其所有的抽象方法。如果有未实现的抽象方法，那么子类也必 须定义为 abstract类
七.接口
如果一个类中的全部方法都是抽象方法，全部属性都是全局常量，那么此时就可以将这个类定义成一个接口。
优点： 1、 降低程序的耦合性 2、 易于程序的扩展 3、 有利于程序的维护
interfance 接口名
{
全局变量;
常用方法;
}
class 子类 implements 父接口1,父接口2...{ }
以上的代码称为接口的实现。
可以多继承
interfance c extends A,B{
}
抽象类和接口区别
1、抽象类要被子类继承，接口要被类实现。
2、接口只能声明抽象方法，抽象类中可以声明抽象方法，也可以写非抽象方法。
3、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
4、抽象类使用继承来使用， 无法多继承。 接口使用实现来使用， 可以多实现
5、抽象类中可以包含static方法 ，但是接口中不允许（静态方法不能被子类重写，因此接口中不能声明 静态方法）
6、接口不能有构造方法，但是抽象类可以
八.多态
多态：就是对象的多种表现形式，（多种体现形态）
ps: 方法的重载 和 重写 也是多态的一种， 不过是方法的多态（相同方法名的多种形态）。
重载： 一个类中方法的多态性体现
重写： 子父类中方法的多态性体现。
类似于基本数据类型的转换：
· 向上转型：将子类实例变为父类实例
格式：父类 父类对象 = 子类实例 ；
· 向下转型：将父类实例变为子类实例
格式：子类 子类对象 = （子类）父类实例 ；
九.instanceof
作用： 判断某个对象是否是指定类的实例，则可以使用instanceof关键字
格式： 实例化对象 instanceof 类 //此操作返回boolean类型的数据
十.内部类
成员内部类
成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。
不过要注意的是，当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默 认情况下访问的是成员内部类的成员。
如果要访问外部类的同名成员，需要以下面的形式进行访问： 外部类.this.成员变量 外部类.this.成员方法
外部使用成员内部类
Outter outter = new Outter();
Outter.Inner inner = outter.new Inner();
成员内部类是最普通的内部类，它的定义为位于另一个类的内部，形如下面的形式：
class Outer
{
private double x = 0;
public Outer(double x)
{
this.x = x;
}
class Inner
{ //内部类
public void say()
{
System.out.println("x="+x);
}
}
}
局部内部类
局部内部类是定义在一个方法或者一个作用域里面的类
局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及 static修饰符的
匿名内部类
匿名内部类由于没有名字，所以它的创建方式有点儿奇怪。创建格式如下：
new 父类构造器（参数列表）|实现接口（） { //匿名内部类的类体部分 }
1、使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能 继承一个类或者实现一个接口。
2、匿名内部类中是不能定义构造函数的。
3、匿名内部类中不能存在任何的静态成员变量和静态方法。
4、匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。
5、匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。 6、只能访问final型的局部变量
静态内部类
静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。 静态内部类是不需要依赖于外部类对象的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非 static成员变量或者方法.
class Outter {
public Outter() {
}
static class Inner {
public Inner() {
}
}
}
十一.异常
什么是异常
异常是在程序中导致程序中断运行的一种指令流。
比如
当j 为 0 时，就会发生异常
为了保证程序出现异常之后仍然可以正确的执行完毕，所以要采用异常的处理机制
处理异常
try{
// 有可能发生异常的代码段
}catch(异常类型1 对象名1){
// 异常的处理操作
}catch(异常类型2 对象名2){
}...
finally{
// 异常的统一出口
}
try+catch 处理流程
- 一旦产生异常，则系统会自动产生一个异常类的实例化对象。
- 那么，此时如果异常发生在try语句，则会自动找到匹配的catch语句执行，如果没有在try语句中，则会将异常抛出.
- 所有的catch根据方法的参数匹配异常类的实例化对象，如果匹配成功，则表示由此catch进行处理。
finally:
不管有没有异常，最后都要执行的代码
异常处理流程
异常体系结构
throw关键字
异常指的是Exception ， Exception类， 在Java中存在一个父类Throwable（可能的抛出）
Throwable存在两个子类：
1.Error：表示的是错误，是JVM发出的错误操作,只能尽量避免，无法用代码处理。
2.Exception：一般表示所有程序中的错误，所以一般在程序中将进行try…catch的处理。
多异常捕获
1、 捕获更粗的异常不能放在捕获更细的异常之前。
2、 如果为了方便，则可以将所有的异常都使用Exception进行捕获。
catch(异常类型1 |异常类型2 对象名)
{
//表示此块用于处理异常类型1 和 异常类型2 的异常信息
}
throws使用
throws 使用
表示方法中不处理异常，而交给调用处处理
格式： 返回值 方法名称()throws Exception{
}
RuntimeExcepion与Exception的区别
因为NumberFormatException并不是Exception的直接子类，而是RuntimeException的子类，只要是 RuntimeException的子类，则表示程序在操作的时候可以不必使用try…catch进行处理，如果有异常发生，则由JVM进 行处理。当然，也可以通过try catch处理。
9217
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
