JAVA面向对象总结

面向对象的多态性

学习目标：

1. Object类的toString()与equals(Object obj)方法
2. 面向对象的多态性
3. 抽象类与接口
   一：Object类
   Object类是所有Java类的根基类(“祖先类”)
   如果在类的声明中未使用extends关键字指明其基类，则默认基类为Object类
   public class Person{
   ...
   }
   等价于：
   public class Person extends Object{
   ...
   }
   1.toString()方法
   Object类中定义有public String toString()方法，其返回值是String类型，描述当前对象的有关信息。
   如果直接打印某对象的引用，则默认会调用这个对象的toString()方法，默认打印的内容中包含这个引用所指向的内存地址。
   可以根据需要在用户自定义类中重写toString()方法。
   2.equals()方法
   Object类中定义有public boolean equals(Object obj) 方法，提供定义对象是否“相等”的逻辑。
   Object的equals方法定义为：x.equals(y)，当x和y指向同一个地址时返回true，否则返回false。
   String类中已经重写了equals(Object obj)方法，重写后的方法比较的是两个字符串的”内容”是否一样(注意：==比较对象的引用)。
   可以根据需要在用户自定义类型中重写equals方法。
   二:多态性
   封装是为了保护属性的一种操作，继承是为了扩展类的功能

是由封装性和继承性引出的面向对象程序设计语言的另一特征。
多态的体现
从方法的角度来看：
方法的重载与重写
重载(overloading)：根据传入的参数不同，完成的功能也不同
重写(override)：子类根据需求重写父类中的方法。
从对象的角度来看：
对象的多态性主要分为两种：
向上转型： 子类对象->父类对象 (程序会自动完成)
格式：
父类 父类对象=子类实例
向上转型后，因为操作的是父类对象，所以无法找到在子类中定义的新方法;但如果子类重写了父类的某个方法，则调用的是重写后的方法。
向下转型：父类对象->子类对象 (必须明确的指明要转型的子类类型)格式：
子类 子类对象=(子类)父类实例
注意：向下转型前先要向上转型。
instanceof关键字
在java中可以使用instanceof关键字判断一个对象是否属于一个类的实例
格式：
对象 instanceof 类 返回boolean类型
final关键字
在JAVA中声明类、属性和方法时，可以使用关键字final来修饰。
注意：
1.final修饰变量(成员变量或局部变量),则成为常量，只能赋值一次
final 类型 variableName;
修饰成员变量时，定义时同时给出初始值，而修饰局部变量时不做要求。
2.final修饰方法，则该方法不能被子类重写
final 返回值类型 methodName(paramList)
{
…
}
3.final修饰类，则类不能被继承
final class finalClassName{
…
}
三：抽象类与接口
用abstract修饰的类即为抽象类
abstract class 抽象类名{
}

抽象类不能被实例化，必须被继承，抽象方法必须被重写，生成它的子类。
由abstract修饰的方法就是抽象方法，抽象方法没有方法体。
抽象类不一定要包含抽象方法，若类中包含了抽象方法，则该类必须被定义为抽象类
如果一个子类没有实现抽象父类中所有的抽象方法，则子类也成为一个抽象类。
构造方法、静态方法、私有方法、final方法不能被声明为抽象的方法。
接口
接口（interface）是抽象方法和常量值的定义的集合。
接口是一种“标准”、“契约”。
从本质上讲，接口是一种特殊的抽象类，这种抽象类中只能包含常量和方法的定义，而没有变量和方法的实现。
接口的声明语法
包括接口声明和接口体
完整的接口声明:
[public] interface 接口名称[extends listOfSuperInterface] { … }
接口体包括常量定义和方法定义
常量定义: type NAME=value; 该常量被实现该接口的多个类共享; 具有public ,final, static的属性.
方法体定义:具有 public和abstract属性
接口的实现类
与抽象类一样，接口要使用也必须通过子类，子类通过implements关键字实现接口
一个类可以实现多个接口,在implements子句中用逗号分开
非抽象子类必须实现接口中定义的所有方法

实现格式：
class 子类 implements接口A，接口B…{
}
接口的使用规则
接口中所有的方法都是public abstract。
在接口中声明方法时，不能使用static，final，synchronized，private，protected等修饰符。
一个接口可以继承自另一个接口。
java中不允许类的多继承，但允许接口的多继承。

接口中可以有数据成员，这些成员默认都是public static final
接口的用途
用处
(1)通过接口实现不相关类的相同行为,而无需考虑这些类之间的关系.
(2)通过接口指明多个类需要实现的方法
(3)通过接口了解对象的交互界面,而无需了解对象所对应的类

第八天课程内容

学习目标：
1.基本数据类型的包装类
2.String类、StringBuffer类、StringBuilder类
3.内部类
一：基本数据类型的包装类
Java语言针对所有的基本数据类型都提供了对应的包装类。
基本数据类型————————包装类
byte（字节———————— java.lang.Byte
char（字符）——————— java.lang.Character
short（短整型）—————— java.lang.Short
int（整型）———————— java.lang.Integer
long（长整型）—————— java.lang.Long
float（浮点型）—————— java.lang.Float
double（双精度）————— java.lang.Double
boolean（布尔）—————— java.lang.Boolean
包装类和基本类型
基本数据类型转换为包装类：Integer intValue = new Integer(21);
包装类转换成基本类型：Integer integerId=new Integer(25); int intId=integerId.intValue();
自动装箱、拆箱
JDK5.0中为基本数据类型提供了自动装箱(boxing)、拆箱(unboxing)功能：
装箱：将基本数据类型包装为对应的包装类对象
拆箱：将包装类对象转换成对应的基本数据类型
Integer intObject = 5;
int intValue = intObject;
包装类并不是用来取代基本类型的
二：字符串相关类

1. String类
   (1) String代表字符串类型，字符串的内容本身不可改变，字符串存储于“字符串常量池”中。
   (2)String的两种实例化方式
   a:直接赋值法：
   eg: String str=“Hello World”;
   b:通过new操作符实例化：
   eg: String str=new String(“Hello World”);
   (3)一个字符串就是一个String类的匿名对象。
   所谓匿名对象，就是在堆内存中开辟了空间，但在栈内存中并没有引用指向的对象。
   (4)字符串常用方法

2. StringBuffer类：
   (1)StringBuffer代表可变的字符序列。
   StringBuffer称为字符串缓冲区，它的工作原理是：预先申请一块内存，存放字符序列，如果字符序列满了，会重新改变缓存区的大小，以容纳更多的字符序列。
   (2)StringBuffer是可变对象，这个是与String最大的不同(如果连续操作String对象，则会产生大量的“垃圾”，而且“断开-连接”很频繁。)
   3.StringBuilder类
   StringBuilder和StringBuffer功能几乎是一样的，只是 StringBuilder是线程不安全的
   三：内部类
   1.在类的内部定义另一个类。如果在类Outer的内部再定义一个类Inner，此时Inner就称为内部类，而Outer则称为外部类。
   2.内部类的定义格式
   3.内部类在编译完成后也会产生.class文件，而文件名称则是”外部类名称$内部类名称.class”
   public class 外部类{
   //外部类的成员
   public class 内部类{
   //内部类的成员
   }
   }
   使用内部类的原因
   比如：心脏属于人类的某个部分：但心脏不能简单用属性或者方法表示一个心脏，因为心脏也有自己的属性和行为，所以需要写在人类的内部
   好处:
   1 可以方便地访问外部类的私有属性
   2 减少了类文件编译后的产生的字节码文件的大小

缺点：使程序结构不清楚
1.成员内部类
成员内部类中不能定义static变量
成员内部类持有外部类的引用
在文件管理方面，成员内部类在编译完成后也会产生.class文件，而文件名称则是”外部类名称$内部类名称.class”
外部实例化成员内部类的格式：
外部类.内部类 内部类对象=外部类实例.new 内部类();
2.静态内部类

如果一个内部类使用static声明，则此内部类就称为静态内部类，其实也相当于外部类。可以通过外部类.内部类来访问。
静态内部类不会持有外部类的引用，创建时可以不用创建外部类对象
静态内部类可以访问外部的静态变量，如果访问外部类的非static成员变量必须通过外部类的实例访问
外部实例化静态内部类对象的格式：
外部类.内部类 内部类对象= new 外部类.内部类();
3.局域内部类
局域内部类是定义在一个方法中的内嵌类，所以类的作用范围仅限于该方法中，而类生成的对象也只能在该方法中使用。
局域内部类不能包含静态成员
特别注意：局域内部类要想访问包含其的方法中的参数，则方法中的参数前必须加上final关键字(JDK<=1.7)。
4.匿名内部类
如果一个内部类在整个操作中只使用一次的话，就可以定义为匿名内部类
没有名字的内部类，这是java为了方便我们编写程序而设计的一个机制，因为有时候有的内部类只需要创建一个它的对象就可以了，以后再不会用到这个类，这时候使用匿名内部类就比较合适