1面向对象的思想
   anything is an Object（万物皆对象） 
   符合人们客观看待世界的规律

2抽象，从对具体的对象中抽取有用信息
   对象有其固有属性，对象的方法，即对象的行为（对象能做什么）
   对象本身是简单的（功能简单），多个对象可以组成复杂的系统（对象之间彼此调用对方的方法）

3面向对象的优点  
   1）对象应当是各司其职（功能简单），各尽所能（把自己的功能作到最好）（弱耦合性实现了前面所述的对象的特点）                                       
   2）对象的耦合性，是对象之间的联系，对象和系统之间的联系
      对象的耦合性要尽量的弱，也就是对象之间的联系尽可能的弱，对象和系统之间的联系尽可能的弱
      弱耦合性要通过一个标准来实现
   3）可重用性
      对象的功能越简单，复用性就越好（对象的耦合性弱，复用性就比较强）
   4）可扩展性
      系统的可插入性，是在系统中加入新的对象之后的系统稳定性
      对象的可替换性，是在系统中替换原有的对象之后的系统的稳定性

4面向过程和面向对象的比较
   面向过程是先有算法，后又数据结构 --- （怎么解决问题）
   面向对象是先有对象（数据结构），后有算法（对象间的方法调用） --- （用什么做） 

5类的定义
  1）属性
     类型  变量名； --> 实例变量，系统赋初始值
                 默认值         使用范围          命名冲突
     实例变量  系统赋初始值   在类的内部使用   允许实例变量和局部变量发生命名冲突，变量的值->局部优先
     局部变量  先赋值后使用   定义他的代码块   同范围内不允许两个局部变量发生命名冲突

  2）方法的定义：
   不允许方法的声明和实现分开
   方法声明的组成：
   (a)方法的修饰符（0或多个修饰符出现的顺序无关） |
   (b)方法的返回值类型                            |顺
   (c)方法名                                      |序
   (d)方法的参数表                                |向
   (e)方法中允许抛出的异常                        |下
                                                  V        
6方法的重载
   java中方法的重载（overload）方法名相同，参数表不同（个数，类型，排列顺序），其他部分可以不同
   调用时要给出明确参数并确定调用某一方法在编译时，编译器会根据参数选择适当的方法，所以重载也叫编译时多态                                                                                                      
   ** 方法的重载可以屏蔽一个对象同一类方法由于参数不同所造成的差异 **

   向上就近匹配原则
   如果方法的参数表中的数据类型和调用时给出的参数类型不尽相同时会根据向上匹配的就近原则（类型就近向上转化匹配）

    public void m(byte a,short b){
       System.out.println("m(byte,short)");
    }

    public void m(short a,byte b){
       System.out.println("m(short,byte)");
    }
    此时若用2个byte作为参数调用m()方法，编译会出错，因为按照向上就近匹配原则，提升哪个都可以，出现语义不明确的错误

7构造方法
  1）方法名与类名相同，无返回值
  2）系统提供默认无参的，空的构造方法
  3）若自定义一个有参的构造方法，则系统将不提供无参的，空的构造方法
  不能手工调用，在一个对象的生命周期中，只会被调用一次

8对象的创建
   Java在堆中创建对象的过程：
    1）分配空间 
    2）初始化属性，若声明实例变量的时候没有初始化，用默认值初始化属性 
    3）调用某个构造方法（前提：不考虑继承关系）

    Student s；  //声明一个Student类的对象变量
    s = new Student();  //调用Student类的无参的构造方法，创建一个对象,把这个对象的地址赋给一个Student类的引用
    （引用指向了这个对象，引用中保存对象的首地址，以后都是通过引用访问这个对象的属性和方法）

    s.age    s引用所指向的对象的age属性

9变量 
   包括简单变量（原始数据类型），对象变量    
   简单变量传值，对象变量传址！

   static void method3(Student s){
     s=new Student();      //创建一个新对象，把对象的地址赋给形参的引用
     s.age=20;             //改变新对象的状态
   }

   Student stu=new Student(); 
   System.out.println(stu.age);   // 打印出Student类的age属性的初始值
   method3(stu);     //method3方法返回，形参s指向的被改变的对象已经成为了垃圾对象
   System.out.println(stu.age);   //打印的仍是原来那个对象的age的值

10this
   是一个引用，指向的是自己，即当前对象（哪个对象调用了方法，哪个对象就是当前对象）
   可以用来区分实例变量和局部变量this.age = age ;
   this(),他表示调用本类其他的构造方法，注，只能写在构造方法的第一行   


项目练习：
项目名称:Bank Account Management System 银行账户管理系统 简称BAM
项目描述:这是一个基于C/S结构的银行账户在线管理系统,用户可以通过ATM终端界面来操作自己的银行账户.
项目实施方式:这是一个同步练习,随着达内CoreJava课程的深入,这个项目将趋于完整,学员的任务是随着知识点的深入,完成每一个进阶的项目要求.

练习1:
(面向对象基础语法)
写一个账户类(Account)

属性:
id:账户号码 长整数
password:账户密码  String

1复习
   面向对象思想
   符合我们看待客观世界的规律
   Everything is an object
   对象：客观存在，有什么（属性），能做什么（方法）
   每个对象都是简单的，有简单的对象拼装成复杂的系统

   面向对象的优点：
   1）各司其职，各尽所能
   2）弱耦合性
   3）可重用性，可扩展性

   类：对象共性的抽象，客观对象在人脑中的主观反映
       对象的模版

   属性：在类里，但在任何方法之外定义的一个变量 --- 实例变量
         有默认值，访问范围，至少是本类内部，可以和局部变量发生命名上的冲突，局部优先，this区分
   方法：方法定义（声明对象能做什么）/方法实现（怎么做）                
         定义：修饰符 返回值类型 方法名 （参数表） 抛出的异常
         重载（Overload）：方法名相同，参数表不同
                           编译时多态，编译器根据参数表选择一个方法
         为什么要有方法的重载？
         屏蔽一个对象同一类方法由于参数表不同所造成的差异
         就近向上匹配
   构造方法：没有返回值，方法名和类名是相同的，系统提供默认无参的空的构造方法，** 建议自己写无参构造
             构造对象的过程：
             1）分配空间
             2）初始化属性
             3）调用构造方法  

   类名 引用名=new 类名(构造参数);

   方法参数传递规则：
   简单类型参数：传值
   对象类型参数：传引用，实参和形参指向同一个对象              

2面向对象的三大特征：封装继承多态

   java中的封装

   封装，一个对象和外界的联系应当通过一个统一的接口，应当公开的公开，应当隐藏的隐藏
  （对象的属性应当隐藏），一个对象的内部是透明的，就是把对象内部的可透明性和隐藏的特性区分开，该透明的透明，该隐藏的隐藏
  （封装的属性）java中类的属性的访问权限的默认值不是private，要想隐藏该属性或方法，就可以加private（私有）修饰符，来限制只能够在类的内部进行访问
   对于类中的私有属性，要对其给出一对方法（getXxx(),setXxx()）访问私有属性，保证对私有属性的操作的安全性
   方法的封装，对于方法的封装，该公开的公开，该隐藏的隐藏方法公开的是方法的声明（定义），即（只须知道参数和返回值就可以调用该方法），隐藏方法的实现会使实现的改变对架构的影响最小化
   封装会使方法实现的改变对架构的影响最小化
   完全的封装，类的属性全部私有化，并且提供一对方法来访问属性                                              

   Java Bean 一种组件规范 --> 所有属性私有，访问方法按照命名规范setXxx(),getXxx()方法

3java中的继承

   继承，是对有着共同特性的多类事物，进行再抽象成一个类这个类就是多类事物的父类父类的意义在于可以抽取多类事物的共性
   泛化：把共性从子类中抽取出来
   特化：现有父类，再有子类的过程
   父类与子类 -> 从一般到特殊的关系

   java中的继承要使用extends关键字，并且java中只允许单继承，也就是一个类只能有一个直接的父类
   这样就是继承关系呈树状，体现了java的简单性

   子类只能继承在父类中可以访问的属性和方法（实际上父类中私有的属性和方法也会被继承但子类中无法访问罢了）
   实际上一个子类对象中包含一个父类对象

   访问控制修饰符:（可以修饰属性和方法）
  private修饰符，表示只有本类内部可以访问，不能继承
  default修饰符，方法不加修饰符，会默认为default，表示在同一个包中可以访问，父子类在同一包中，子类可以继承父类的相应内容（可以修饰类）
  protected（保护）修饰符，表示同一包中可以访问，不同包的子类也可以访问继承
  public修饰符，表示公开，在任何地方都可以访问，能继承（可以修饰类）
  修饰符的权限是由上而下逐渐变宽的

  继承的意义，就在于子类可以在父类的基础之上对父类的功能进行发展,继承可以使系统的耦合性降低，也就是使对象间的联系便的松散，使多类对象间的联系用其父类对象代替

  注意：构造方法不能被继承

  父类的属性及方法的确定：要从子类的角度来看子类间的共性，当所有子类都有这个属性时，就应当考虑是否该放在父类中，方法也是如此，方法可以被看作是对象的行为，而类的方法这时这一类对象所共有的行为，所以也应当在方法的确定时注意是不是所有的子类型中都需要有这种方法，并且会根据不同的类型的行为的方式也不同才可以覆盖着个方法

4java中方法的覆盖
  子类中有和父类中可访问（可继承到子类）的同名同返回类型同参数表的方法，就会覆盖从父类继承来的方法
  在父子类中，出现方法名相同，参数表不同的情况，叫方法的重载
  方法覆盖父子类返回值类型也要相同
  注意：在jdk1.4以前要求方法的覆盖时，需要方法的返回值，参数表，方法名必须严格相同，而在jdk1.5中方法覆盖，子类的中覆盖的方法的返回值可以是父类中被覆盖的方法的返回值类型的子类型
  注意：子类的方法覆盖父类的方法时，方法的修饰符要么相同，要么子类中的方法的修饰符表示的访问权限要宽于父类父类中的私有方法，不能被继承到子类，就是说子类中即使将其覆盖了也不会有多态         
  注意：父子类中有同名的属性不叫子类覆盖了父类的属性，这种情况较作属性的遮盖（shadow）

5super关键字
  (1)区分父子类间的属性遮盖和方法覆盖
  (2)super()，表示在子类的构造方法中调用父类的构造方法（可以通过这种方法在子类的构造方法中初始化父类中的属性），super()也只能出现在构造方法的第一句上super(),在子类的构造方中指明构造父类时调用哪一个父类的构造方法构造父类
  super,这里所表示的是一个父类的对象，可以通过super来使用父类中可以访问的方法（可以在父类中定义setXxx()，getXxx()方法来访问父类中的私有属性），super可以屏蔽父子类中同名属性的冲突  
  注意：在写类的时候，一定要写默认无参的构造方法，如果一个构造方法的第一句既不是this(),也不是super()时，那么就会在这里隐含的调用他的父类的无参的构造方法，即隐含的有super()

6创建对象的过程
   1）递归的构造父类的对象，默认调用父类无参的构造方法super()
   2）分配本类空间
   3）初始化本类实例变量（属性）
   4）调用本类的构造方法  

7java中的多态 --- 运行时多态
   Animal a = new Dog();   //引用类型可以是对象类型的父类
   对象类型   客观类型
   引用类型   主观类型
   以子类覆盖了父类的方法为前提

   1）对象类型不变  
   2）只能对一个对象调用引用类型中定义的方法
   3）运行时会根据对象类型找覆盖之后的方法

   Animal a = new Dog(); 
   Dog d = new Dog();
   a = d;      //把子类引用赋值给父类引用，是合法的
   d = (Dog)a; //把父类引用赋值给自类引用，需要强转

   引用 instanceof  类名    //判断前面的引用和后面的类是否兼容
   可以翻译为是不是
   a instanceof Dag;    //a指向的对象是不是Dog类
   一般用在强制类型转换之前，避免转换异常

   多态可以使代码变得更通用，以适应需求的变化也就是定义在父类中的方法，可以在子类中有不同的实现将其覆盖，在为父类型的对象变量赋值相应需要功能的子类的对象实例
   可以屏蔽不同子类的差异

作业：
1.设计一个形状类,方法:求周长和求面积
  形状类的子类:Rect(矩形),Circle(圆形)
  Rect类的子类:Square(正方形)
  不同的子类会有不同的计算周长和面积的方法
  创建三个不同的形状对象,放在Shape类型的数组里,分别打印出每个对象的周长和面积


2.某公司的雇员分为以下若干类：
Employee：这是所有员工总的父类，属性：员工的姓名,员工的生日月份方法：getSalary(int month) 根据参数月份来确定工资，如果该月员工过生日，则公司会额外奖励100元
SalariedEmployee：Employee的子类，拿固定工资的员工属性：月薪
HourlyEmployee：Employee的子类，按小时拿工资的员工，每月工作超出160小时的部分按照1.5倍工资发放属性：每小时的工资每月工作的小时数
SalesEmployee：Employee的子类，销售人员，工资由月销售额和提成率决定属性：月销售额提成率
BasePlusSalesEmployee：SalesEmployee的子类，有固定底薪的销售人员，工资由底薪加上销售提成部分属性：底薪

写一个程序，把若干各种类型的员工放在一个Employee数组里，写一个函数，打印出某月每个员工的工资数额注意：要求把每个类都做成完全封装，不允许非私有化属性

java教程1-java125
java教程3-java125