黑马程序员_Java基础知识对象的三大特性及相关知识点

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

 

 

 

面象对象编程 OOP  =Object Oriented Programming

针对 OOP 还有一种 Aspect Oriented Programming(AOP) 代理模式实现 , 是叫面象切面编程 .

所有的事物都有两个方面：

有什么（属性）：用来描述对象。

能够做什么（方法）：告诉外界对象有那些功能。

后者以前者为基础。

大的对象的属性也可以是一个对象。

 

面象对象三大特征 : 封装 , 继承 , 多态 .

匿名对象 :Car c=new Car();

                c.num=5;

上面等同于 : new Car().num=5;

匿名对象调用对象的属性没意义 .. 经常用匿名来调用方法 .

什么时候使用匿名对象 ?

1.       当对对象的方法只调用一次时可以用匿名对象来完成 , 这样写比较简化 . 但如果进行多个成员调用就必须给这个对象起个名字 .

2.       可以将匿名对象作为实际参数进行传递 .

main()

{

       show(new Car());

}

public static void show(Car c)

{

       c.num=5;

       c.run();

}

 

封装 : 是指隐藏对象的属性和实现细节 , 对外仅提供公共访问方式 .

好处 : 将变化隔离 . 便于使用 . 提高复用性 . 提高安全性 .

封装原则 : 将不需要对外提供的内容隐藏起来 , 把属性都隐藏 , 仅对处提供公共方法对其访问 .

封装属性用 private 来修饰 . 封装后要提供外部对其访问的接口 . 之所以提供访问方式 . 就因为可以在访问方式中加入逻辑判断等语句 , 对访问的数据进行操作 , 提高代码的健壮性 .

构造函数什么时候定义呢 ?

当分析事物时 , 该事物存在具备一些特性或者行为 , 那么将这些内容定义在构造函数中 .

面试时候会用到 . 构造代码块 ,, 作用 : 给对象初始化 , 对象一建立就运行 . 而且先去构造函数 . 构造代码块是给所有对象进行统一初始化 . 定义一些对象共性初始化内容 .

 

this 关键字 , 用于区分局部变量和成员变量同名的情况 . 前面加上 this 就代表本类的对象 . 它代表它所在函数所属对象的引用 . 和 this 相对的是 super 他对应父类的

this 的应用 . 当定义中的功能时 , 该函数内部要用到调用该函数的对象时 . 用 this 来表示这个对象 , 只要是本类功能内部使用了本类对象 , 都可以用 this 来表示 .

this 语句构造函数间调用 .

public class ConstructorTransfer {

    public static void main(String[] args){

    // 调用 Person(String name,int age){   }   

Person p = new Person( "lisi" ,20);

    }

 

class Person{

    private String name ;

    private int age ;

   

    Person(){

          

    }

    Person(String name){

       // 调用 Person(){ }

this ();

    }

    Person(String name, int age){

       // 调用 Person(String name){ }

this (name);

       this . age =age;

    }

}

this 语句只能定义在构造函数第一行 .

 

Static 关键字 .

静态方法只可以访问静态成员 .

因为静态优先于对象存在 , 所以静态中不可以出来 this 和 super 关键字 .

在什么时候定义静态函数呢 .?

当功能没有访问到对象的非静态数据 ( 对象的特有数据 ) 时 , 那么该功能可以定义为静态 , 静态函数也只能访问静态成员 .

给主函数传递参数

 

静态的应用 - 工具类

工具类中每一个方法都没有用到对象中的特有数据 , 可以将方法名都定义成静态的通过类名调用 , 为了更为严谨 , 强制让该类不能建立对象 , 可以通过构造函数私有化 .

 

静态代码块特点 : 随着类的加载而执行 , 只执行一次 , 并先于主函数执行 . 用于给类进行初始化的 .

static

{

    syso(“ 这是静态代码块 ”);

}

 

{

    syso(“ 这是构造代码块 , 用来给所有对象统一初始化的 .”);

}

 

 

public class MainDemo {

 

    /**

      * @param args

      */

    public static void main(String[] args) {

       // TODO Auto-generated method stub

       System. out .println(args. length );

       System. out .println(args[0]);

    }

}

用上面的类在 Myeclipse 中 Run As- à Run Configurations.. 里边的 Arguments 中传递参数

Test1

Test2

Test3

运行上面的程序输出的结果为 :

3

Test1

上面的在命令行窗口也可以执行 , 直接在 java 类名 后面加上空格和要加的参数 , 参数之间用空格隔开 .

 

用 Javadoc 制作帮助文档 . 

/**

@param                       这是显示参数的

@return                       这是显示返回值的 .

*/

 

单例设计模式 : 分为懒汉式和饿汉式

开发中常用饿汉式 , 面试经常会考懒汉式 .

饿汉式对象建立时就初始化 .

// 饿汉式

class SingleE{

    private SingleE(){ }

    private static SingleE s1 = new SingleE();

    public static SingleE getInstance(){

       return s1 ;

    }

}

// 懒汉式 为了保证安全同步代码块 .

class SingleLan{

    private static SingleLan s2 = null ;

    private SingleLan(){ }

    public static SingleLan getInstatce(){

       if ( s2 == null ){

           // 同步使用的锁是该类的字节码文件 .

           synchronized (SingleLan. class ) {

              if ( s2 == null )

                  s2 = new SingleLan();

           }

       }

       return s2 ;

    }  

}

 

面象对象 , 继承  

把对象中的共性描述提取出来单独封装成一个类 , 然后让对象所属的类 extends 这个封装的类 .

继承提高了代码的复用性 , 让类与类之间产生关系 , 有了这个关系才有了对象的多态性 .

必须是类与类之间有所属关系才可以继承 , 不能单独的为了实现某功能而继承 . 所属关系 is a

Java 是单继承多实现 , 支持多层继承 .

继承  查阅父类功能 , 创建子类对象使用该功能 .

当之类继承父类 , 沿袭了父类的功能到子类中 , 但子类的该功能和父类的不一致时没有必要定义新功能 , 而是使用覆盖 (Override), 保留父类的功能定义 , 并重写功能内容 .

Override 时要保证子类的权限不能比父类的权限小 .

在对子类对象进行初始化是地 , 父类的构造函数也会运行 , 因为子类的构造函数默认第一行都有一条隐式的语句 super());

super(): 会访问父类中空参数的构造函数 . 而且中所有的构造函数默认第一行都是 super());

为什么子类一定要访问父类中的构造函数 .?

因为父类中的数据子类可以直接获取 , 所以子类建立对象时 , 需要先查看父类是如何对这些数据进行初始化的 .

如果要访问父类中指定的构造函数 , 可以通过手动定义 super 语句的方式来指定 .

Super() 语句一定子类构造函数的第一行 .

子类的实例化过程 .

子类中所有的构造函数默认都会访问父类中空参数的构造函数 . 当父类中没有空参的构造函数时 , 子类必须通过 super 语句形式来指定要访问的构造函数 . 子类的构造函数第一行也可以手动指定 this 语句来访问本类中的构造函数 . 子类中至少会有一个构造函数会访问父类中的构造函数 .

 

final 关键字

final 修饰的类不可以被继承

final 修饰的变量是一个常量 , 只能被赋值一次 .

final 修饰的方法可以被继承 .不可以被覆盖

内部类只能访问被 final 修饰的局部变量 .

 

抽象类

抽象方法

当多个类中出现相同功能 , 但是功能主体不同 . 这时可以进行向上抽取 . 只抽取功能定义 , 而不抽取功能主体 . 用 abstract 来修饰 . 抽象方法必须存放在抽象类中 . 抽象类不可以 new 创建对象 .. 抽象类中的方法要被使用 , 必须由子类复写所有的抽象方法后 , 建立子类对象调用 . 如果子类只覆盖了部分抽象方法 . 那么该子类还是一个抽象类 .

 

模板方法设计模式 .

在定义功能时 , 功能的一部分是确定的 , 但是有一部分是不确定 , 而确定的部分在使用不确定的部分 , 那么这时就将不确定的部分暴露出来 , 由该类的子类去完成 .

 

 

接口 Interface

格式特点 :

1.        接口中常见定义 : 常量 , 抽象方法 .

2.        接口中的成员都有固定修饰符

常量 :public static final

方法 :public abstract

接口中的成员都是 public 的

接口 : 是不可以创建对象的 , 因为有抽象方法 . 需要被实现 , 子类对接口中的抽象方法全都覆盖后 , 子类才可以实例化 , 否则子类是一个抽象类 .

接口可以被类实现 , 一个类可以实现多个接口 , 也是对多继承不支持的转换形式 ,Java 支持多实现 .

 

面象对象第三大特性 多态

多态可以理解为事物存在的多种体现形态 .

Animal c=new cat;

1.        多态的体现

父类的引用指向自己的子类对象 .

父类的引用也可以接收自己的子类对象 .

2.        多态的前提

必须是类与类之间有关系 , 要么继承 , 要么实现 .

通常还有一个前提 , 存在覆盖 .

3.        多态的好处

多态的出现大大的提高程序的扩展性 .

4.        多态的应用

5.        多态的弊端

提高了扩展性 , 但是只能使用父类的引用访问父类中的成员 .

 

6.        多态的出现代码中的特点

在多态中成员函数的特点 :

在编译时期 : 参阅引用型变量所属的类中是否有调用的方法 , 如果有 , 编译通过 , 如果没有 , 编译失败 .

在运行时期 : 参阅对象所属的类中是否有调用方法 .

简单总结就是编译时看左边 , 运行时看右边 .

 

在多态中 , 成员变量的特点 :( 非静态的 )

无论编译和运行 , 都参考左边 ( 引用型变量所属的类 )

 

多态类型提升 , 向上转型

强制将父类的引用转成子类类型 . 向下转型

 

面向对象 , 内部类 .

内部类的访问规则 :

1. 内部类可以直接访问外部类中的成员 , 包括私有 .

因为内部类中持有了一个外部类的引用 , 格式   外部类名 .this

1. 外部类要访问内部类 , 必须建立内部类对象 .

 

 

如果要直接访问内部类中的成员 , 成员变量要写内部类的全名 , 要说明该内部类属于哪一个外部类 .

注意匿名内部类的书写规范 .

匿名内部类 :

1.        匿名内部类其实就是内部类的简写格式 .

2.        定义匿名内部类的前提 :

内部类必须是继承一个类或者实现接口 .

3.        内部类的格式 .:  new 父类或者接口 ( ){ 定义子类的内容 }

4.        其实匿名内部类就是一个匿名子类对象 .( 定义类和建立对象封装在一起 ). 可以理解为带内容的对象 .

5.        匿名内部内中定义的方法最好不要超过 3 个 .

 

 

 

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