java 面向对象总结

			#一、概念

##1.1基本概念
1、面向对象：三大特征： 封装、继承、多态
2、对象：客观事物的实体（具体）
3、类：具有相同属性和方法的一组对象的集合（抽象）
##1.2 定义类
1 、定义类
访问修饰符]class 类名{}
访问修饰符有4种：public private protected 默认的
2、属性
对象所拥有的静态特征即属性
3、方法
对象执行操作的行为称为类的方法
方法的返回类型有两种：
1、无返回值：void(),方法体中不必使用"return"关键字，但是可以使用return关键字，退出方法。
2、有返回值：在方法体中一定要使用”return“，否则编译报错，小括号的参数类型和参数名必须对应，多个参数列表用 ”，“分隔开
##1.3创建和使用对象
1.创建对象 ：类名 对象名=new 类名（）；
（1）左边的类名：对象 的数据类型
（2）右边的类名（）：类的构造方法
面向对象的优点：（1）与人的思维一样；（2）信息隐藏；（3）提高了程序的可重用性，一个类可以创多个对象
对象数组：
方法重载
同一个类中，方法名相同，参数类型或者参数个数不同，与返回值无关，简化类调用方法的代码
成员变量：
作用域：直接在类中定义的变量(成员变量）,即方法的外部
在整个类中都可用，如果访问权限允许，在类外部都可以使用，有默认初始值（基本数据类型为0，引用类型为null)
局部变量： 定义在方法内部的变量，只是在方法体里面使用时需要赋值，否则编译报错,同一个方法体内不允许有同名的局部变量，不同方法体之间可以有同名的局部变量，
局部变量具有更高的优先级
数据类型
基本数据类型:byte short char int long float double boolean
引用数据类型:String 类 数组 接口
构造方法
创建一个对象时会自动调用该类的构造方法
作用：进行数据的初始化
注意：构造方法无返回值，默认构造方法没有参数 ，方法名与类名相同
构造方法的重载:
this关键字：
是对一个对象的默认引用。每个实例方法内部都有一个this引用变量
作用：
（1）用this 调用成员变量，解决同名冲突
（2）this调用成员方法
（3）this调用重载的构造方法，只能在构造方法中使用，且必须是构造方法的第一条语句

注意：this不能调用（类变量和类方法 static修饰），也不能调用局部变量

					****封装****

作用：（1）将类的状态信息隐藏到类内部，不允许外部程序直接访问，通过该类提供的方法来访问（2）事物相对独立性 （3）隐藏类的实现细节（4）松耦合（降低代码之间的关联性，和依赖性）
步骤：
（1）将类的属性私有化（private）
（2）为私有属性添加getter/setter()方法。在setter方法中利用判断语句进行赋值限制
（3）设置必要的读取权限
包
作用：（1）包也是封装的一种形式 （2）防止命名冲突，不同的包中类才能重名（3）类似于文件夹，将类组合成较小的单元
定义包：
package 包名：在Java源文件的第一条非注释语句，一个源文件只能右一个包
包名全部小写的ASCII字母
使用import导入包
static 关键字（静态）
使用static修饰的属性和方法属于类，不属于对象，可以直接通过类名"."直接调用类的成员
(1)修饰属性
static修饰的属性称为：静态变量或者类变量*
无static修饰的叫实例变量
（2）修饰方法
static修饰的方法叫做静态方法或者类方法
无static修饰的叫实例方法
注意：静态方法中不能直接访问实例变量和实例方法
实例方法中可以直接调用类中定义的静态常量和静态方法

**常量final修饰，**不能改变
eg: static final int PERSON_LIVE=1;

				**继承**

作用：
（1）解决代码冗余
（2）实现代码重用
（3）增加软件的可扩充性
Java中类只支持单继承（extends）
子类可以继承父类的哪些内容：
（1）继承public和protected修饰的属性和方法，无论是否在一个包里面
（2）继承默认访问修饰符修饰的属性和方法，子类和父类必须在一个包里面
子类不能继承父类的哪些内容：
（1）无法继承父类的构造方法
（2）private修饰的属性和方法
（3）不同包的默认访问修饰符
使用继承和重写完善类的结构：
步骤：（1）extends继承（2）super()调用父类成员 （3）重写父类的方法输出子类自身的信息

使用super关键字调用父类成员
注意：super只能用在子类，
不能访问父类的private成员
作用：（1）访问直接父类中被屏蔽的内容（2）提高代码的重用性和灵活性
（3）super可访问父类的构造方法、父类的成员、父类的属性、父类的方法

实例化子类对象时构造方法的执行
一、类的构造方法总执行：
创建该类的对象（实例化）
创建该类的子类的对象（子类的实例化）
子类在实例化时先执行父类的构造方法，后执行自身的构造方法
子类继承父类时构造方法的调用规则如下：
（1）如果子类的构造方法中没有通过super调用父类的有参构造，也没有通过this调用自身的其他构造，则会先调用父类的无参构造
（2）如果子类的构造方法中通过super调用父类的有参构造，则执行相应的父类的构造方法，不执行父类的无参构造方法
（3）如果子类的构造方法中通过this调用自身的其他构造，则遵循以上条
注意：如果存在多级继承，在创建一个子类对象时，一直执行到顶级父类（Object）的无参构造方法

object类所有类的父类
object类常用的方法：
toString()…返回字符串对象
equals()…比较是否为同一个对象
clone()…生成当前对象的一个副本，并返回
hashCode()…返回该对象的哈希代码值
getClass()…获得当前对象所属的类信息，返回class对象

方法重写（Overriding）：
重写与被重写的方法要求：
方法名相同 参数列表相同 返回值类型相同或是其子
注意：重写方法不能缩小被重写方法的访问权限

					**多态**

含义：一个特定类型的变量可以引用不同类型的对象，并且能自动调用引用对象的方法，实现不同的操作重写是多态的基础

1、向上转型：子类向父类的转换
Pet pet=new Dog();
将一个父类的引用指向一个子类的对象
调用子类覆盖父类的方法，但是，调用不了子类特有的方法

2、向下转型：父类类型转换为子类类型
Dog dog=(Dog)pet;将一个指向子类对象的父类引用赋给一个子类的引用
实现子类特有的方法
注意*：转换时如果不是真实的子类时会出现异常借助于（ instanceof ）关键字，该关键字前面的对象类型必须和后面的参数所指定的类右继承关系，不然编译错误*
多态的应用：
1、使用父类作为方法的形参

//主人类
class Host(){
public void letCry(Pet pet){
pet.cry();//调用动物叫的方法
	}
}
//调用代码
public class Test{
public  static void  main(String[]args){
Host host=new Host();
Pet pet;
pet=new Dog();
host.letCry(pet);
}
}

2、使用父类作为方法的返回值

//主人类
class Host{
//赠送动物
public  Pet donatePet(String type){
Pet pet;
if(type==dog){
pet=new Dog();
}
return pet;
}
}
//调用类
public class Test{
public static void main(String[]args){
Host host=new Host();
Pet pet;
pet=host.donatePet("dog");
pet.cry();
}
}

注意：
1、抽象类不能被实例化
2、子类如果不是抽象类，则必须重写抽象父类的全部抽象方法
3、abstract 修饰符不能和 final 修饰符一起使用
4、abstract 修饰抽象方法，没有方法体
5、private 关键字不能用来修饰抽象方法

多态的优点：
可替换性 可扩充性 接口性 灵活性 简化性

				**抽象类和接口**
****被abstract 修饰的类，抽象类里面的抽象方法，没有方法体
抽象类没有具体的实现，但是其子类如果不是抽象类则子类可以实例化。，抽象方法只能在抽象类中****

接口：可看作特殊的抽象类，全部为抽象方法
不能被实例化
注意：1、定义接口interface，访问修饰符只能是public
2、接口成员为全局常量和公共的抽象方法
3、子类通过implements 实现接口
定义和实现接口时：
1、接口和类、抽象类一个层次，命名规则一样
2、修饰符如果是public ，则在整个项目中可见，如果不写，则该接口只能在当前包中可见
3、接口中全部是常量，属性默认用 " public static final "修饰接口中所有属性都是全局静态常量。必须赋初值

//两种定义方式等价，在接口中
public static final int PI=3.14;
int PI=3.14;

4、接口中全是抽象方法，默认public
5、接口不能实例化，不能有构造方法
6、接口之间可以通过extends继承，且一个接口可以继承多个接口，但接口不能被继承，
7、类可以通过implements 实现多个接口，该类必须实现接口的全部方法，不然该类必须定义为抽象类
8、一个类如果既有继承又有实现接口，必须继承在前

//继承在前。实现接口在后
//A类继承B类，实现接口c,d,e
public class A extends B implements c，d，e，{}

					**异常的捕获和处理**

异常处理的步骤：

try-catch
try-catch-finally
使用多重catch 块处理

异常的体系结构：
（1）Error类：程序本身无法恢复，内存溢出、动态链接失败、虚拟机错误
（2）Exception类
（3）运行时异常
（4）Checked异常（非运行时异常）
自定义异常

//常见的异常类
Exception //异常层次结构的根
ArithmeticException//算术错误异常，如除数为零
ArrayIndexOutOfBoundsException//数组下标越界
NullPointerException//空指针（访问的对象成员为null）
ClassCastException//对象强制转换出错
NumberFormatException//数字格式化转换异常，如把abc 转换成数字

异常处理的5大关键字：try catch finally throw throws

try-catch-finally 
try 必须存在。catch 、finally 二者至少出项一个
finally表示总被执行，除非System.exit(1)，退出虚拟机;不执行
//使用多重catch时，catch的排列顺序必须是子类到父类
try{
Scanner input=new Scanner(System，in)；
int totalTime=input.nextInt();
}catch(InputMismatchException e1){
System.err.println("必须输入数字")；
}catch(Exception e2){
System.err.println("发生错误")；
}

使用throws 声明抛出异常
throws声明某个方法可能抛出的各种异常，异常之间用 ”，“ 隔开

使用throw抛出异常
1、throw用于程序员自行产生并抛出异常，throws 用于声明该方法内抛出了异常
2、throw 位于方法体内部，可以作为单独语句使用；throws 必须在方法参数列表的后面，不能单独使用
3、throw 抛出一个异常对象，只能一个；throws 后面跟异常类。可以多个

			**JAVA高级特性**
一、集合框架和泛型

接口：
collection :存储一组不唯一、无序的对象
map:键值对（单向映射），键唯一

collection:
List:存储一组不唯一、有序的对象
set：存储一组唯一、无序的对象
List接口：
（1）ArrayList: 动态数组, 长度可变 ， 内存分配连续空间 存储任何类型的数据，
优点：遍历和随机访问元素的效率高

//ArrayList常用方法
boolean add(Object o);//在列表末尾添加O元素
void add(int index，Object o);//在指定下标位置添加O元素
int size();//元素个数
Object get(int index);//取出该位置下的元素（Object)类型
void set(int index,Object obj);//将该位置的元素替换成obj
boolean contains(Object o);//判断列表是否有O元素
int indexOf(Object obj);//返回该元素在集合中的下标
boolean  remove(Object o);//删除指定元素
Object  remove(int index);//删除对应下标的元素

（2）LinkedList:
存储方式：链表存储方式
优点：插入和删除元素效率比较高

//常用方法
xxxFist();
XXXLast();

set接口
（1）、HashSet–>查找效率高
特点：集合内元素无序 非线程安全 允许集合元素为null

//常用方法
Boolean add();//添加元素
void clear();//清空集合
int size();//集合元素个数
boolean isEmpty();//是否为空
boolean contains();//是否为空
boolean remove();//删除元素

Map接口
存储键值对key–>value 不要求有序，但是唯一

//常用方法
Object put(key,value);//添加键值对
remove(key);//删除key返回对应的value
get(key);//获取key对应的value 如果不存在则返回null
boolean containsKey(key);//是否包含key
boolean containsValue(value);/是否包含value
boolean isEmpty();//是否为空
void clear();//清空
int size();//键值对数
Set key(Set);//获取所有Key的集合
Collection values();//获取所有value 的集合

二、实用类
String类常用的方法

length();//字符串长度
equals();//比较字符串
concat();//连接两个字符串
substring();//提取字符串
indexOf();//索引字符串
split();//拆分字符串
replace()//替换字符串

StringBuffer

//常用方法
toString();//转string
append();//连接字符串
insert();//插入字符串

三、I/O和反射机制
一、反射机制：

//反射在多态中的应用，不用instanceof
package fanshe;

/**
 * 父类：货物类
 */
public  abstract class Goods {
    private  String name;

    public Goods() {

    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    //抽象方法
    public  abstract  void print();
}

package fanshe;
/**
 * 子类
 */
public class Food extends Goods {
    @Override
    public  void print(){
        System.out.println("输出食品名称："+super.getName());
    }

}
package fanshe;

public class Tv extends  Goods {
    @Override
    public void print() {
        System.out.println("输出TV名称："+super.getName());
    }
}
package fanshe;

public class Test {
    //生产一个商品：父类作为方法返回值类型（多态）
    //className用户想要获得的商品类型，这里为 Food Tv 类的完整限定名包括包名
   public  Goods getGoods(String className){
       //获取类型对应的Class对象实例
       //通过Class的newInstance()生成相应类型的实例，即用户所需要的对象
       Goods goods=null;
       try {
           //关键代码
           goods=(Goods)Class.forName(className).newInstance();
       } catch (InstantiationException e) {
           e.printStackTrace();
       } catch (IllegalAccessException e) {
           e.printStackTrace();
       } catch (ClassNotFoundException e) {
           e.printStackTrace();
       }
       return  goods;
   }
        //测试类
    public static void main(String[] args) {
        Test test=new Test();
        //生成用户需要的子类对象(包名.类名)！！！
        Goods goods=test.getGoods("fanshe.Food");
        goods.print();

        Goods goods2=test.getGoods("fanshe.Tv");
        goods2.print();

    }
}
//输出结果：
输出食品名称：null
输出TV名称：null