面向对象

唯物主义，唯心主义

思考: 我的英雄亚瑟，墨子的皮肤金属风暴，我的QQ账号是唯物主义还是唯心主义？

1.概念

对象：模型。把现实世界当中的某个事物拿到计算机语言当中来研究，那么这个事物叫做对象（模型）。

面向对象：对现实世界当中的某个事物在计算机中进行建模，分析的行为或过程。

面向对象力求客观，自然，正确地描述现实世界。

反例：1+1= 2 -> 张三 + 李四 = ?
人类吃饭 -> 数字1吃饭？

抽象：抽象是从众多的事物中抽取出共同的、本质的特征。透过事物的表面现象抓住本质。

共同：1.人都有姓名，年龄，性别…都会吃饭，睡觉…

                 2.英雄都有昵称，性别，种族......都有三个基本技能，都可以回城，平A......

                 3.汽车都有轮子个数，长度，重量，生产厂家......都可以驾驶，维修，加油...

           反例： 学号，教师编号不是人类的共同特征。

                  户藉所在地，说话也不是动物的共同特征。

                  英雄的4技能不是英雄共同的技能（兰陵王有4技能，亚瑟没有）。

                   排量，充电也不是汽车的共同特征。

                  人类有姓名这个特征是正确的，人类有张三这个特征是错误的，不够本质


                  人类有年龄这个特征是正确的，人类有20这个特征是错误的，不够本质


                  人类有性别这个特征是正确的，人类有男女这个特征是错误的，不够本质

类(Class)：用抽象的方式获得事物的本质特征之后，再用概念形式描述它。这样的概念形式称为类

用极简的话说：类是特征的描述。

2 抽象

1）提取事物的静态特征（属性，Field,成员变量表示）

2）提取事物的动态特征(方法，Method，动作，函数)

3）把提取结果放到一个类当中（类的概念：对特征的描述）

对象来源于现实世界，因为它是现实世界某事物的模型

类与对象的区别

1）类是大脑中的概念，不存在于现实世界中。

2）对象来源于现实世界。

思考：周杰伦，音乐，《七里香》，iphone，我手上拿的这台iphone哪些是类，哪些是对象？

类与对象的转换(类派生对象)：

1）.实例化（使用new关建字）

类名称 变量名称 = new 类名称();


 	    抽象(提取对象的特征（属性，方法）)

1.对象 -> 类

	   实例化(具体)

2、类 -> 对象

2）.实例调用属性和方法

2.1） 为属性赋值

2.2 ）读取属性的值

2.3 ）调用方法

格式： 

赋值： 对象.特征 = 0;

取值： 对象.特征

方法: 对象.特征()



对象.特征

this.特征 -> 可以简写为:特征

this.特征() -> 可以简写为:特征()

Student stu = new Student();   -> this: stu

Student stu2 = new Student();   -> this: stu2

当你正好处于这个类的内部时，this可以省略不写


toString()来源于Object类，由于任何类都是继承自Object，所以任何类都拥有toString(),toString()会描述当前类当中的所有属性的值，相当于自我介绍。

构造方法（构造方法是用来创建(构建，构造)当前类的对象，不是普通的方法，具有特殊性）：
1.构造方法的格式
2.特点：
1）构造方法的名称必须与当前类一致
2）构造方法不能写返回值（因为它返回的必然是当前类的对象）
3）默认是存在一个空的构造方法的（只是看不见）
4）构造方法如果显式的写出来，那么隐藏构造将消失，无效
5）一个类中可以定义多个构造方法

ArrayIndexOutofBoudsException [0,9]

NullPointerException 空指针(内存地址)异常

如果对一个null执行除了打印和连接运算以外的其它何意动作均抛出空指针(内存地址)异常

3.面向对向三大特征

3.1 封装：增加代码的不可见性。更好的包装才能更好的保护。
尽可能的隐藏自身的内部结构，减少外界因素的干扰。
只保留一些对外接口使之与外部发生联系。
为什么要封装，为什么要增加不可见性？
举例：1.你在网上买个手机，为什么店家不直接邮手机，而要把手机包起来再邮？
2.瑞士手表，为什么要使用特别难拆的表壳包起来，再戴手上？
3.人的头颅骨是人体最坚硬的部分，目的是为了充分保障大脑的安全运行。
4.一辆汽车正在以100公里速度急速奔跑，如果挂倒挡会怎样？

                       封装需要依赖四个控制访问的修饰符：
                       private 、default、protected、public
                       private:只能在当前类当中访问
                       default：只能在当前类和同一个包当中访问
                       protected：只能在当前类和同一个包以及子类当中访问
                       public：当前类当中，同一包当中

3.2 继承（extends）
继承：子类继承父类，使得子类具有和父类相同的特征(属性，方法)。
class（类）的继承是单继承。
继承的目的：复用
思考：
子类能继承父类所有的属性和方法吗？（不一定，要受控制访问）

构造方法能继承吗？
不能，因为如果子类继承了父类的构造方法，父类的构造在子类中不符合构造方法的规则，也不符合一般方法的规则。父类的构造在子类中没有返回类型，方法名也与子类的类名不相同。不符合java语法规范。

继承通过extends关键字来实现：格式： 在定义子类的时候在子类类名的后面 + extends +父类的类名字

拥有父类的对象实例化的时候，是先实例化父对象，再实例化子对象
new 子类型（）； //1.new 父类型（）；2.new 子类型（）

共同点：
this和super都只能在定义类的过程中使用，如果类已经定义完成进入了实例化阶段是不能使用this和super的。
this与super的区别:

1.this(),super() 这种形式只能用在构造方法当中

 this()是调用当前类的构造方法的意思。
super()是调用父类的构造方法的意思。

2.this.x,super.x  this指代的是当前对象，super指代的是父类对象

 普通方法要求在对象创建完成之后才可以调用。
 this.x()  this指代的是当前对象
 super.x() super指代的是父类对象

  严格来讲:super 只是代表了当前对象中的那部分父类型特征
  3.如果父类当中没有无参构造方法的话，子类必须显式的指出要调用哪一个父类的构造方法

3.3 多态： 多态指的是同一个动作（方法）拥有不同的解释
或同一消息的不同的响应
或同一行为有不同表现

3.3.1 重载: 同一个动作作用在相同的对象上拥有不同的解释
重载是同一类当中多态的体现。重载又称静态多态，又称编译时多态(在编译时可以确定到底调哪一个方法)
3.3.1.1 问， 王者荣耀当中，李白怎样可以从泉水到达龙坑？
1) 走路过去。
2) 使用大乔3技能2.5秒后传送过去
3) 李白的1技能的第3段过去
4) 被对面项羽和苏烈轮流推过去，手段极其残忍，一边推，一边揍，到达龙坑时已是鼻青脸肿，奄奄一息，然后被龙一巴掌拍死。

3.3.1.2 计算正三角形的面积(通过边长,周长，底和高,任意边长和角度都可以)
3.3.1.3 Math函数的求绝对值方法

重载对方法的要求：
1) 在同一个类当中。
2) 方法名相同。
3) 参数列表至少有以下一个不同：个数不同，顺序不同，类型不同。

3.3.2 重写：同一个动作作用在不同的对象上拥有不同的解释 不同（必须在父子类之间）
3.3.2.1 王者荣耀中所有英雄的技能都是多态:

          1) 小乔1技能会丢出一把扇子
          2) 大乔1技能会出现一条流淌的河，短暂沉默敌人
          3) 兰陵王1技能会使用飞刃攻击敌人
           ……这样的例子有100多个

3.3.2.2 长方形求面积解释为：ab,三角形解释为1/2底高，圆解释为PIR的平方。

多态的机制：

		1.声明一个父类型的引用指向具体子类型的实例 
		2.运行时才能绑定 
		3.运行时可变。

重写是父子类当中多态的体现。重写又称动态多态，又称运行时多态(不到运行时无法确定到底调用哪个对象的方法)

		  重写对方法的要求:
		  1) 重写必须发生在父子类当中。
			2) 重写之后的方法必须拥有与原方法相同（一模一样）的方法名、相同的形参列表
			3) 重写之后的方法必须拥有与原方法一致(不是一模一样)(必须是原类型或原类型的子类)的返回值类型
			4) 重写之后的方法不能拥有比原方法拥有更低的访问权限
			5) 重写之后的方法不能比原方法抛出更多的异常，可以相同或更少
			6) 静态方法不存在重写


			重写的出现，使用我们可以面对不同的情况，做出统一地编码。

4.抽象类

4.1 抽象类与抽象方法

 4.1.1 只声明方法的存在而不实现，那么此方法称为抽象方法

 4.1.2 方法所在的类称为抽象类

需使用 abstract 关键字修饰类和方法

举例：计算周长和面积

4.2 抽象类特点:

4.2.1 抽象类当中既可以有抽象的方法，也可以有非抽象(具体)的方法
4.2.2 抽象类的抽象方法，在非抽象的子类中必须被重写
4.2.3 抽象类，不能被实例化。
4.2.4 抽象类，不能是final的。（final修饰类时，此类不能被继承）

5.接口（interface）

5.1 接口概念

   广义上认为：任何约定都称为接口，例如，员工与公司的合同，电视的插头与插座，显卡的制造标准。
   
  狭义上是指：interface，抽象类的变体，为了解决java单继承问题而生（接口是多继承）。
 
interface是一种特殊的abstract class。

ClassCastException: class String cannot be cast to class Integer

类类型强转异常：类（String）不能被强转为Integer

5.2 案例: 求图形的对角线

5.3 接口特点:

  5.3.1 实现接口用implements关键字
  5.3.2 接口是抽象类的变体（因为java不能多继承，才引入的接口）   问：接口能不能被实例化？
 																													  抽象类不能被实例化。
  5.3.3 任何类只能继承自一个类，但可以实现多个接口（接口名称与接口名称之间用逗号隔开）。
  5.3.4 接口可以不用abstract修饰(不修饰也是抽象的)
  5.3.5 接口中的方法只能是抽象的（与abstract无关，写不写abstract都一样。因为既然说interface我们已经是建立在抽象的前题下了 ），default方法除外，以后再说。
  5.3.6 接口中的方法，在实现了它的实现类当中必须被重写(Override)。
  5.3.7 接口当中所有的方法都是public的
  5.3.8 接口当中无法定义变量，只能定义常量

 类   extends     类

  类 implements  接口

 接口 extends  接口


5.4 接口与抽象类的区别:

  5.4.1 类是单继承,接口是多继承(类可以实现多个接口，接口也可以继承多个接口)
  5.4.2 继承抽象类使用extends关键字,实现接口用implements
  5.4.3 抽象类可以有具体方法,接口只能有抽象方法(default除外)
  5.4.4 类可以有变量,接口只能有常量(public static final)