第四章 ---- 面向对象（一）

• • 类和对象
  • 类的成员
  • • 属性
    • • 属性 VS 局部变量
    • 方法
    • • 方法重载
      • 可变个数形参
      • 方法参数的值传递机制
      • 递归方法
    • 构造器
    • 匿名对象
    • javaBean
  • 关键字
  • • return
    • this
    • package
    • import
  • 三大特性
  • • 封装性
    • • 权限修饰符
  • 项目
  • • 客户信息管理系统
    • 类实现栈
    • 类实现队列

面向对象学习的三条主线

1. java类及类的成员：属性，方法，构造器，代码块，内部类
2. 面向对象的三大特征： 封装性，继承性，多态性，（抽象性）
3. 其他关键字：this，super，static，final，abstract，interface，package，import

面向对象特征

类： 抽象的概念（类是设计的重点）
对象：类的实例

属性 = 成员变量 = filed = 域字段
方法 = 成员方法 = 函数

class Person{
	String name;
	int age = 1;


	public void eat(){
		System.out.println("吃饭");
	}
	public void sleep(){
		System.out.println("睡觉");
	}
	public void talk(){
		System.out.println("说话");
	}
}

类和对象的使用

1. 创建类，设计类的成员
2. 创建类的对象
3. 通过”对象.属性“ 或 ”对象.方法“ 调用对象的结构

多个对象，每个对象都独立的拥有一套类的属性。（非static的）

1. 在类中声明的位置不同
   属性：直接定义在类的一对{}内
   局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量

2. 默认初始化值
   属性有默认初始化值
   局部变量没有默认初始化值，意味着局部变量需要显式赋值

3. 内存中位置不同

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

方法内可以调用当前类的属性 和 方法

同一类中，允许存在同名方法，只要它们的参数个数或者参数类型不同即可。
跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！

jdk5.0后加入

//jdk5.0以前： 采用数组形参来定义方法，传入多个同一类型变量
public static void test(int a,String[] books);

//jdk5.0以后：采用可变个数形参来定义方法，传入多个同一类型变量
public static void test(int a,String...books);

基本数据类型：形参接收到的是实参的真实值
引用数据类型：形参接收到的是实参的引用地址值

构造器：创建对象，初始化属性

1. 如果没有显示定义：系统默认提供一个空参构造，权限和类相同
2. 定义格式：权限修饰符 类名(形参){}
3. 构造器可以重载
4. 如果显示定义构造器后，系统将不提供默认空参构造

一般会提供一个空参构造器，创建对象不止有new 的方式 还有 反射等方式一般会用到空参构造

属性赋值的先后顺序:
默认初始化 --> 显示初始化 --> 构造器中赋值 --> 通过"对象.方法" 或 “对象.属性” 的方式，赋值

创建的对象没有显式的赋值给变量名
匿名对象只能使用一次
一般用在方法参数传递中

• 符合一下标准
  类是公共的
  有无参的公共构造器
  有属性，具有对应的get,set方法

• 用户可以使用JavaBean将功能、处理、值、数据库访问 和 其他任何可以用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序使用这些对象。用户可以认为JavaBean提供了一种随时随地的赋值粘贴功能

结束一个方法，结束并返回一个数据
return后不能有执行语句

this:当前对象
可以区分形参和属性同名的情况等
this调用构造器：需要出现在第一行，且不能循环调用

为了更好的管理项目中的类，提供包的概念
需要声明在源文件的首行

1. 在源文件中显示使用import结构导入指定包下得类、接口
2. 使用"xxx.*"的方式，表示可以导入xxx包下得所有结构
3. java.lang包下定义的可以省略
4. 使用本包下定义的可以省略
5. 使用"xxx.*" 方式表明可以调用xxx包下得所有结构。如果是子包下的结构还是需要导入子包的
6. import static: 导入指定类或接口中的静态结构：属性或方法。

• 隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。
• 高内聚，低耦合

问题引入：
属性的封装性，将属性声明为私有的（private），只能通过方法调用，不能直接使用对象点的方式调用
方法调用时可以对属性进行判断处理，这就是封装性的体现

类 :缺省，public
属性，方法，构造器，内部类
private、缺省、protected、public

客户信息管理

public class StackInt {
    private int[] elem;//栈容器(int栈)
    private int size=0;//栈内容量
    private static final int D_SIZE = 100;//最大容量

    public StackInt(){
        this.elem = new int[D_SIZE];//初始化数组
        this.size= 0;//栈的大小是100
    }

    public int getSize(){
        return this.size;
    }
    public int pop(){
        if (isempty() == false){
            return elem[--this.size];
        }else{
            return -1;
        }
    }
    public void push(int data){
        if (isfull() == false){
            this.elem[size++] = data;
        }
    }

    public boolean isfull() {
        if (this.size >= 100) {
            return true;
        } else {
            return false;
        }
    }

    public boolean isempty() {
        if (this.size <= 0) {
            return true;
        } else {
            return false;
        }
    }
    public void empty(){
        this.size = 0;
    }


    public static void main(String[] args) {
        StackInt stackInt = new StackInt();
        for (int i = 0; i < 10; i++) {
            stackInt.push(i);
        }
        while (!stackInt.isempty()){
            System.out.println(stackInt.pop());
        }
    }
}

public class StackInt {
    private int[] elem;//栈容器(int栈)
    private int size=0;//栈内容量
    private static final int D_SIZE = 100;//最大容量

    public StackInt(){
        this.elem = new int[D_SIZE];//初始化数组
        this.size= 0;//栈的大小是100
    }

    public int getSize(){
        return this.size;
    }
    public int pop(){
        if (isempty() == false){
            return elem[--this.size];
        }else{
            return -1;
        }
    }
    public void push(int data){
        if (isfull() == false){
            this.elem[size++] = data;
        }
    }

    public boolean isfull() {
        if (this.size >= 100) {
            return true;
        } else {
            return false;
        }
    }

    public boolean isempty() {
        if (this.size <= 0) {
            return true;
        } else {
            return false;
        }
    }
    public void empty(){
        this.size = 0;
    }


    public static void main(String[] args) {
        StackInt stackInt = new StackInt();
        for (int i = 0; i < 10; i++) {
            stackInt.push(i);
        }
        while (!stackInt.isempty()){
            System.out.println(stackInt.pop());
        }



        for (int i = 20; i!=0;i/=2){
            stackInt.push(i%2);
        }
        int size = stackInt.getSize();
        for (int i = 0; i < size; i++) {
            System.out.print(stackInt.pop());
        }
    }
}