004：Java面向对象

相关术语

OOP ：oriented object program，面向对象编程
OOA：oriented object analyze，面向对象分析
OOD：oriented object design，面向对象设计

面向对象的概念

• 理解面向对象

面向对象是相对于面向过程而言
面向对象和面向过程都是一种思想
面向过程强调的是功能和行为
面向对象将功能封装进对象，强调具备了功能的对象
面向对象是基于面向过程的

• 面向对象的特点

是一种符合人们思考习惯的思想
可以将复杂的事情简单化
将程序员从执行者转换成了指挥者
完成需求时：先要去找具有所需的功能的对象来用；如果该对象不存在，那么创建一个具有所需功能的对象；这样简化开发并提高复用。

• 面向对象开发，设计，特征

开发的过程：其实就是不断的创建对象，使用对象，指挥对象做事情。
设计的过程：其实就是在管理和维护对象之间的关系。
面向对象的特征：
封装：encapsulation
继承：inheritance
多态：polymorphism

类和对象的关系

使用计算机语言就是不断的在描述现实生活中的事物。
Java中描述事物通过类的形式体现，类是具体事物的抽象，概念上的定义。
对象即时该类事物实实在在存在的个体

• 类的定义

生活中描述事物无非就是描述事物的属性和行为。
如：人有身高，体重等属性，有说话，打球等行为。
Java中用类class来描述事物也是如此。
属性：对应类中的成员变量。
行为：对应类中的成员函数。
定义类其实在定义类中的成员。（成员变量和成员函数）。
定义方式：
class 类名{
成员属性1；
成员属性2；
成员函数
}

• 成员变量和局部变量的区别？

成员变量：
1.成员变量定义在类中，在整个类中都可以被访问。
2.成员变量随着对象的建立而建立，存在于对象所在的堆内存中。
3.成员变量有默认的初始化值。
局部变量:
1.局部变量只定义在局部范围内，如：函数内，语句内等。
2.局部变量存在于栈内存中。
3.作用的范围结束，变量空间会自动释放。
4.局部变量没有默认的初始化值。

• 创建对象使用对象

class ClassDemo
{
    public static void main(String[] args){

    Person p = new Person();
    p.age = 18;
    p.weight = 90;
    p.hight = 160;
    System.out.println("年龄："+p.age+"身高："+p.hight+"体重：" + p.weight);
    p.run();
    }
}

class Person
{
    int age;
    int weight;
    int hight;

    void run(){
        System.out.println("正在跑......");
    }
}

• JVM堆栈初探

• 匿名对象

匿名对象是对象的简化形式
匿名对象的两种使用情况
1：当对象方法仅进行一次刁艳红的时候
2：匿名对象可以作为实际参数进行传递

封装

封装：是指隐藏对象的属性和实现细节仅对外提供公共的访问方式。
好处：将变化隔离；便于使用；提高重用性；提高安全性。
封装的原则:将不需要对外公开的内容都隐藏起来，把属性都隐藏提供公共方法对其访问。

• private，私有的，关键字

构造函数

如果没有定义构造函数，系统会自动给一个空构造函数
如果定义了其他构造函数，系统不再分配空构造函数，需要手动写

• 构造代码块

静态代码块在类加载之间执行
静态成员之间可以互相访问，按序执行
静态成员不可以访问非静态成员，因为静态成员先于非静态成员加载
非静态成员可以访问静态成员
静态成员通过类访问
非静态成员通过对象访问

注意点：main函数为什么是静态的？
因为如果main函数是非静态的，加载main函数首先得创建对象，创建对象得加载main函数所以这样导致死循环，程序不能运行，所以main函数必须是静态的。

Javabean
pojo:plain old java object 普通古老的Java对象
对象的成员变量有相应的get和set方法，通过get和set方法来访问成员变量

this关键字

特点：this代表其所在函数所属对象的引用，换而言之this代本类对象的引用
什么时候用this关键字？
当在函数内所需要用到调用该函数的对象时就用this
this（）访问构造函数，this（）的调用必须放到第一条语句，放到后面报错

static静态关键字

static关键字：用于修饰成员（成员变量和成员函数）
被修饰以后的成员具备以下特点：
1:随着类的加载而加载
2：优先于对象存在
3：被所有对象所共享
4：可以直接被类名调用
使用注意：

静态方法只能访问静态成员
静态方法中不可以写this，super关键字
主函数是静态的

继承

• 继承的概述

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
多个类可以称为子类，单独这个类称为父类或者超类。
子类可以直接访问父类中的非私有的属性和行为。
通过extends关键字让类与类之间产生继承关系
class SubDemo extends Demo{ }
继承的出现提高了代码的复用性。
继承的出现让类与类之间产生了关系，提供了多态的前提。

• 继承的特点

• super关键字

super()
访问超类的构造函数
必须是第一行代码
构造函数的首行要么是this（）要么是super（）默认是super（）

• 函数覆盖override

• 子类的实例化过程

• final关键字

• 抽象类-AbstractClass

  • 抽象类概述

  

  • 抽象类的特点

  

  • 示例

class AbstractClass
{
    public static void main(String[] args){
        Dog d = new Dog();
        d.run();
    }

}

abstract class Animal
{
    abstract public void run();
}

class Dog extends Animal
{
    public void run(){
        System.out.println("run......");
    }

}

• 抽象类相关问题

  抽象类中是否有构造函数？
  抽象类中是有构造函数的
  抽象关键字abstract不可以和那些关键字共存？
  private+abstract
  final+abstract
  抽象类中可不可以没有抽象方法？
  抽象类中是可以没有抽象方法的

• 接口

  

  • 接口的特点

  

  • 抽象类和接口

  

多态

• 成员变量可以被覆盖，成员函数不能被覆盖。

内部类

GUI:grapphic user interface,图形用户接口

适配器模式

GOF：gang or four,四人帮

class AdapterDemo{
    public static void main(String[] args) {
        Button b1 = new Button();
        /* b1.addListener(new MouseListener(){
            public void onClick(){
                System.out.println("single click!");
            }
            public void onDclick(){
                System.out.println("double click!");
            }
        });*/
        b1.addListener(new MouseAdapter(){
            public void onClick(){
                System.out.println("single click");
            }
            public void onDclick(){
                System.out.println("double click");
            }
        });
        b1.click();
        b1.doubleClick();
    }
}

class Button{
    private MouseListener listener;
    public void addListener(MouseListener listener){
        this.listener = listener;
    }
    public void click(){
        listener.onClick();
    }
    public void doubleClick(){
        listener.onDclick();
    }
}

// mouse listener
interface MouseListener{
    public void onClick();
    public void onDclick();
    public void rightClick();
    public void xxClic();
}
// mouse adapter
abstract class MouseAdapter implements MouseListener
{
    public void rightClick(){}
    public void xxClic(){} 
}

异常：Exception

• 异常的体系
  • Throwable:可抛出的，是多有异常和错误的超类。
    throw:抛出异常对象的指令。
    throws:在方法中声明抛出异常的关键字。
    • Error
      • 通常出现重大问题如：运行的类不存在或者内存溢出等。
      • 不编写针对代码对其处理
    • Exception
      • 在运行时出现，可以通过try catch finally处理
  • Exception和Error的子类名都是以父类名作为后缀。

1 : java.lang.NullPointException.
2 : ...ArryIndexOutOfBoundsException.
3 : ClassCastExceptionl.

可以有多个catch语句，但是catch语句的顺序要注意，子类的catch语句应该放在前面，否则代码不可达。编译也不能通过，这是违反逻辑的。
方法在重写时，不能声明抛出新的异常，只能是原有的异常体系（异常的子类是可以的）。
throw抛出异常后，后面的代码不执行。
try，catch捕获异常，后面的代码继续执行。

包：package

1:对类文件进行分类管理
2：给类提供多层命名空间
3：写在程序文件的第一行
4：类名的全称是：包名.类名
5：包也是一种封装形式

完整类名：包名 +“.” + 类名，例如：cn.com.xxx.ClassName
例如：package cn.com.xxx
包的编译：
javac -d classes ClassName.java（-d：指定存放classes文件的位置，同时生成对应的文件夹目录树)
javac -cp classes -d .xxx.java（-cp指定编译程序时需要搜索的类路径顺序。）
包的执行：
java -cp classes cn.com.think.ClassName（运行Java程序需要指定类的完整类名）
含有包名的类需要使用public修饰，否则无法在其他的包中访问。
public class ClassDemo{

}
引入包 中的类需要使用import关键字。
import cn.com.think.ClassDemo
public class xxxx{
,}

包之间的访问

1：被访问的包中的类权限必须是public
2：类中的成员权限public或者protected
3：protected是为其他包中的子类提供的一种权限

jar ：是Java archive，Java归档或者叫打包。
另外还有war，ear，har等
可用jar -h查看帮助示例
1：将foo目录下的所有文件进行归档，生成xxx.jar
jar cvf xxx.jar -c foo/ .
2：归档时指定入口点，会在清单文件中添加main-class属性
jar cvfe xxx.jar cn.com.think.e.E -c foo/classes .
3：通过jar文件执行程序
java -cp xxx.jar cn.com.think.e.E
java -cp xxx.jar;yy.jar;classes;..;d:\xx cn.com.think.e.E
java -jar xxx.jar