面向对象知识点整理

-------android培训、java培训、期待与您交流！ ----------

面向对象的总结


1. 面向对象的思想
   面向过程向面向对象转换，执行者变成指挥者


2. 类和对象的关系
   |-- 类是描述现实生活中具体存在的事物
   |-- 对象就是现实生活中确实存在的个体
   |-- 类好比是图纸，对象好比是按照图纸生产的汽车


3. 建立对象，调用方法 
  |-- 类  变量 = new 类();
  |-- 变量.方法();


4. 匿名对象
  |-- new 类();
  |-- 函数只需要一次调用的时候，使用
  |-- 将匿名对象作为参数传递，其实传递的是对象的引用地址


5. 封装(private)
  |-- 将实现细节隐藏，对外提供公共访问方式(set , get方法)
  |-- 提高安全性，代码复用性


6. getset函数


7. 构造函数 (与类名一致)
  |-- 构造函数，对象初始化建立的时候，调用一次，仅仅一次
  |-- 建立对象的时候，给对象中的成员变量赋值
  |-- 构造函数可以进行重载


8. this关键字
  |-- this表示本类对象的引用，谁调用的，this就表示这个对象
  |-- this用于区分成员变量，和局部变量的重名情况
  |-- this语句，可以在构造函数之间调用，保证this语句是构造函数的第一行
  |-- 构造函数，不允许递归调用


9. static关键字
  |--static静态修饰符
  |--被static修饰的成员变量，属于对象的共享数据
  |--被static修饰的成员，类名直接调用
  |--被static修饰的成员，随着类的加载而加载，随着类的消亡而消亡，方法区的静态区
  |--静态不能调用非静态
  |--当出现对象共享数据的时候，使用static修饰
  |--当类中的成员函数，都没有访问过类中的成员变量，函数使用static修饰


10. main函数
  |--主函数是静态的
  |--不需要对象，直接被类名调用


11. 文档工具类的制作
  |-- 数组的操作，制作的工具类
  |-- 私有了构造函数，其他函数，都是静态
  |-- java中的特有注释/** */
  |-- javadoc -d 目录 -author -version 文件名.java


12. 单例设计模式()，保证对象的唯一性
  |-- 饿汉式，代码必须会写
  |-- 懒汉式，代码必须会写，开发不用，面试考
   

//饿汉式单例模式(安全,开发常用模式)
public class Single
{
private Single()//将构造函数私有化
{}


private static final Single s = new Single();//创建本类对象并私有化,防止其他类修改


public static Single getInstance()//主函数没有对象,所以只有静态之后才可以访问
{
return s;
}

}
public class SingDemo
{
public static void main(String[] args)
{
//new Single();
//new Single();
Single ss=Single.getInstance();//静态方法调用
System.out.println(ss);
}
}
 
 //懒汉式(延迟加载,不安全,面试常用)
  class Single 
 {
private Single(){}
private static Single s=null;
public static Single getInstance()
{
if(s==null)
{
s=new Single();
}
return s;
}
 }
 public class SingDemo
 {
public static void main(String[] args)
{
Single ss=Single.getInstance();
System.out.println(ss);
}
 }
  
13. 继承
  |-- extends继承父类
  |-- 父类是子类共性内容提取出来的
  |-- 代码复用性，减少代码量(*******)
  |-- 继承的出现，使类和类出现了关系，这个关系导致了面向对象第三个特征多态
  |-- 子类可以直接使用父类成员(不是全部)

  示例:

 class person{

person(){}

public void run(){}

}

class Student extends Person{

person(){}

public void run(){}

}

14. 继承中，成员特点
  |-- 成员变量
    |-- super关键字，区分子类和父类重名的成员变量
    |-- 子类有就用子类的，子类没有用父类
  |-- 成员函数
    |-- 子类和父类出现了一模一样的函数，函数的覆盖特性
    |-- 覆盖保证子类中的权限大于或者等于父类中的权限
    |-- 手机的例子(重点)
  |-- 构造函数'
    |-- 子类继承不了
    |-- 子类的构造函数第一行默认有个super()
    |-- 子类的所有构造函数都会访问父类的构造函数
    |-- 子类中的构造函数，可以间接的访问父类构造函数

函数继承和函数覆盖示例
 //手机代码示例
class Phone
{
public void call()
{
System.out.println("通话......");
}
public void incoming()
{
System.out.println("来电显示.......");
}
}
class NewPhone extends Phone
{
public void incoming() 
{
super.incoming();
System.out.println("彩铃"); 
System.out.println("大头照...");
}
}


class Iphone extends Phone
{
public void incoming()
{ 
super.incoming();
System.out.println("视频电话.....");
System.out.println("Hello World!");
}
}

class OverrideDemo01 
{
public static void main(String[] args) 
{
Iphone p = new Iphone();
p.call();
p.incoming();
}
}

15. 子类的实例化过程
    1. 先加载父类的class文件，进入方法区
    父类中有静态的话，静态进到静态区  
    父类中，如果有静态代码块，这个时候，静态代码块就运行了
 
   2. 加载子类的class 文件，进入方法区
    子类中有静态的话，静态进到静态去
    子类中如果有静态代码块，静态代码块就运行了


    子类继承父类了，class进方法去的时候，会在子类上打一个表示 super


   3. 建立子类对象的时候 new Zi();
    开辟内存空间。运行父类的构造代码块
    运行父类的构造函数  (如果需要赋值的话，这时就赋值了)
 
    运行子类的构造代码块
    运行子类的构造函数(如果需要赋值的话，这时就赋值了)


    构造代码块，和构造函数运行完毕后，将对象的内存地址
    赋值给函数中的局部引用型变量


16. final关键字
   |-- final是修饰符，修饰类，函数，成员变量，局部变量
   |-- 被final修饰的类，不能再派生子类
   |-- 被final修饰的方法，不能被覆盖
   |-- 被final修饰的变量，只能一次赋值，不能再改值
   |-- 被final修饰的变量，其实是一个常量


17. 抽象类
   |-- 抽象类的由来，子类中共性方法抽取的，但是父类中抽取的方法，描述不清楚
   |-- 抽象方法，没有方法体，用abstract进行修饰，抽象方法存在于抽象类中
   |-- 类，也要有abstract修饰
   |-- 抽象类中，可以没有抽象方法
   |-- 抽象类，不能实例化对象
   |-- 子类继承抽象类，覆盖抽象类中的全部抽象方法，建立子类的对象
   |-- 子类继承了抽象了，没有完全覆盖抽象方法，子类还是一个抽象类，依然不能建立对象
   |-- 建立子类的对象，需要子类完全覆盖抽象方法
   |-- 经理和员工的例子(**************)

//经理和员工的代码示例
abstract class Company
{
//私有化变量,防止外部修改
private String name;
private int age;
private int number;
private double pay;
//初始化变量 
Company(String name,int age,int number,double pay)
{
this.name = name;
this.age = age;
this.number = number;
this.pay = pay;
}


//提供供外部访问的方法
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public double getPay()
{
return pay;
}
abstract public void job();


}

class Manager extends Company     //经理类继承公司类
{
private double bouns;

Manager(String name, int age, int number, double pay, double bouns)
{
super(name,age,number,pay); 
this.bouns = bouns;
}
public void job()
{
System.out.println("姓名:"+getName()+"\t年龄:"+getAge()+"\t工资"+getPay()+"\t奖金:"+bouns);
}
} 


class Programmer extends Company
{
Programmer(String name, int age, int number, double pay)
{
super(name,age,number,pay);
}
public void job()
{
System.out.println("姓名:"+getName()+"\t年龄:"+getAge()+"\t工资:"+getPay());
}
}


class ExtendsDemo01
{
public static void main(String[] args)
{
Manager m = new Manager("zhangsan",20,007,10000.0,15000.0);
m.job(); 

Programmer p = new Programmer("lisi",22,001,12000.0);
p.job();
}
}

18. 接口
   |-- 接口中的成员是固定的(******)
     public static final int X = 3;
     public abstract void show();s


19. 类与接口的关系
   |-- 一个子类可以实现多个接口
   |-- 覆盖接口中的抽象方法
   |-- 建立子类对象


20. 继承和实现的区别
     1. 继承只能单继承
     2. 可以多实现
     3. 继承后，子类可以直接使用父类的功能
     4. 实现后，子类必需全部覆盖父类中，或者接口中的抽象方法
     5. 实现的出现，避免的单继承的局限性


21. 接口和抽象类的区别
   |-- 接口中的方法全部是抽象方法‘
   |-- 抽象类中可以有普通方法
   |-- 子类继承抽象类，直接使用抽象类中的非抽象方法
   |-- 子类全部覆盖接口中的全部方法才能建立对象
   |-- 抽象类是这个继承体系中的共性内容
   |-- 接口是这个体系的扩展内容
   |-- 继承是一个 is - a 关系，谁是谁的一种
   |-- 接口是一个 like a 关系，看起来像谁


22. 多态
   |-- 一个事物具备的多种形态
   |-- 代码体现 父类或者接口引用指向自己的子类对象
   |-- 这个父类引用或者接口引用，只能调用子父类中的公共方法，不能调用子类特有方法
   |-- 进行类型的强制转换 已经提升为父类类型的子类，转回到子类类型
   |-- 判断一个引用是否属于这个类型 instanceof


23. 多态的优势：降低程序的耦合性，提高程序扩展性，提高后期可维护性


24. 主板和USB设备案例()

//电脑运行控制,电脑运行基于主板
interface  PCI
{
public abstract void open();
public abstract void close();
}
class MainBord
{
public void run()
{
System.out.println("MainBord run...........");
}
public void usePCI(PCI p)
{
p.open();
p.close();
}
}
class SoundCard implements PCI
{
public void open()
{
System.out.println("SoundCard run...........");
}
public void close()
{
System.out.println("SoundCard close...........");
}
}
class NetCard implements PCI
{
public void open()
{
System.out.println("NetCard run...........");
}
public void close()
{
System.out.println("NetCard close...........");
}
}

class DuoTaiDemo01
{
public static void main(String[] args)
{
MainBord mb = new MainBord();
mb.run();
mb.usePCI(new SoundCard());
mb.usePCI(new NetCard());
}
}


25. 数据库中的多态(了解)

//数据库的例子
interface Base
{
public abstract void insert();
public abstract void delete();
public abstract void update();
public abstract void select();
}
class MySql implements Base
{
public   void insert()
{
System.out.println("Mysql...插入操作...");
}
public   void delete()
{
System.out.println("Mysql...删除操作...");
}
public   void update()
{
System.out.println("Mysql...修改操作...");
}
public   void select()
{
System.out.println("Mysql...查询操作...");
}
}


class Oracle implements Base
{
public   void insert()
{
System.out.println("Oracle...插入操作...");
}
public   void delete()
{
System.out.println("Oracle...删除操作...");
}
public   void update()
{
System.out.println("Oracle...修改操作...");
}
public   void select()
{
System.out.println("Oracle...查询操作...");
}
}
class Db
{
public static void db(Base d)
{
d.insert();
d.delete();
d.update();
d.update();
}
}


class DbBase
{
public static void main(String[] args)
{
Db dd = new Db();
dd.db(new MySql());
dd.db(new Oracle());
}
}




 

26. 多态中，子父类中的成员特点
   多态中，子父类中成员变量，成员函数，静态成员函数，静态成员变量的特点
   |-- 非静态成员函数，编译看左边，运行看右边
   |-- 其他情况，编译看左边，运行看左边


27. Object类
  |-- equals，子类覆盖equals方法，建立自己独特的比较方式
  |-- toString，子类覆盖toString方法，建立自己的独特字符串表现形式


28. 内部类
  |-- 格式  外部类名.内部类名 变量 = new 外部类名().new内部类名();
  |-- 格式  外部类名.内部类名 变量 = new 外部类名.内部类名();
  |-- 格式  外部类名.内部类名.函数名
  |-- 内部类出现在局部位置上，访问外部类中函数的局部变量，这个局部变量需要加final


29. 匿名内部类
  |-- 前提：必须实现接口，继承一个类
  |-- 格式 :
       接口名 变量 = new 接口(){
         覆盖接口方法
       };
       变量.方法


30. 异常
  异常
    |-- 异常的面向对象思想
      java将异常都封装成了对象
    
    |--异常体系:
       Throwable
          Exception
   小问题，可处理
 Error
   大问题，必须修改代码


    异常的处理方式(******************)
    try{
      //可能发生异常的代码
    }catch(异常类 变量){
     // 处理方式
    }


31. 打印异常信息的3个常用方式
   |--getMessage();
   |--toString();
   |--printStackTrace() ;


32. 异常的第二种处理方式 抛出异常(********面试)
   |-- throw
   |-- throws


33. 编译时期异常和运行时期异常
   |-- 调用了抛异常的方法，调用者没有处理异常
   |-- 运行时期异常对象描述 RuntimeException 和他的子类
   |-- 这个异常，在运行时期抛出，不需要在函数上声明，也不需要处理
   |-- 运行时期异常，一旦出现，程序停止运行，修改源代码


34. 自定义异常
   |-- java中，没有完全描述所有的异常，有的异常是java没有描述的，需要自定义异常
   |-- 继承Exception 或者 继承RuntimeException
   |-- 调用父类构造方法，传递异常信息


35. 老师电脑上的异常案例(**************)


36. 包
   |-- 分类管理类文件
   |-- 提供多层命名空间
   |-- package
   |-- 就是文件夹


37. 包与包之间类的访问
   |-- public protected default private
   
38. import 关键字
   |-- 导入类
   |-- 需要子包中的类，导入到子包


39. jar
   |-- jar -cvf 文件名.jar  包