corejava学习2（三大特性）

面向对象的三大特性：

封装(encapsulation)，继承(inheritance)，多态(poymorphism)

 

Public    private

 

属性都要隐藏；为各个属性设置函数；该隐藏的隐藏，该公开的公开；

Private 只在本类以内使用

 

Public    公开的                          宽

Protected  本包可见，其他包子类可见        到

Default   本包类可见                      窄

Private    类内部使用

 

private 修辞的方法和属性不能被继承，其实是不能访问没有权限。

 

 

继承

1、父子类

2、单继承   根 object

3、覆盖

 

创建子类对象时先一定会创建父类对象

 

构造方法的第一句

1 、在程序里没有指明调用 哪一个父类的构造方法，jvm会自动调用父类的构造方法，一定调用的是无参。根本类构造方法的声明没有任何关系。

2、显示的写Super,jvm会根据要求调用相应的构造方法

3、在构造方法的第一句是this（）；先在本类的构造方法之间调用，看被调用的那个本类构造方法的第一句是什么。

 

Super 指代直接父类对象

 

 

多态（只根方法有关）

      （*属性只看编译时类型）

     Animal a=new Dog();

     编译看前边（animal），运行看后边(dog)

     Dog b=(Dog)a;

 

运行时类型不会改变。对象不会应人的主观意识而改变。

对于一个引用只能调用编译时类型里的已知方法。

运行时会自动运行已覆盖过的方法。

 

运行时多态叫覆盖；

编译时多态叫重载；

 

Class 类名｛

Private 属性（有什么）

无参的构造方法 public 类名（）｛｝

有参的构造方法（给属性赋值）

Set和get (设置属性和获得属性)

业务方法（做什么）

 

｝

 

封装

1、               属性一般都是隐藏，用访问控制修饰符private隐藏。隐藏后属性只能在类内访问，程序可以根据需要提供get和set,手动写代码实现。

    2、    

 

 

继承：从一般到时特殊的关系，可以设计成继承

  特点：共性写在父类里面，特性写在子类

 

什么样的功能和属性可以继承到子类？对于父类里的属性和方法子类有权访问的，我们称为可以继承

 

 

 

访问控制修饰符：

Private  本类   不可以继承

Default  本包  不一定（同包可继承，不同包不可继承）

Protected 本包和子类  可以继承

Public  公开    可以继承

 

Override（覆盖）  继承父类的方法后，用自己特殊属性和方法改写父类里面的共性的实

1、发生在子类和父类之间

2、方法名相同，参数相同，返回类型相同

3、访问权限不能更严格，只能等于或者更加宽松

 

Java只支持单继承，类的继承在树状结构，object是所有类的父类

 

创建对象的过程

1、分配内存（包括所有的属性的内存，本类属性，父类的共性）

2、创建父类对象

3、初始化本类的实例变量

4、执行本类的构造方法

 

 

Super：

Super指代父类构造方法，一般写在子类构造方法的第一句，指明调用父类的哪一个构造方法，默认情况调用的是父类的无参构造方法

Super指代父类对象，调用遮盖的属性或者是被覆盖的方法，指代的是在创建子类对象过程中，由java自动创建的那个父类对象

 

多态：子类对象可以当成父类对象来用

      一个父类型的引用可能指向的是一个子类对象

 Super s＝new sub（）;

 

Sub su＝new sub（）

Super s＝su

   S的编译时类型：super           运行时类型：sub

多态的特点：

1、            对象的运行时类型永远不会发生改变;

2、            对一个引用，只能调用编译时类型面定义的方法

3、            运行时会根据运行时类型自动寻找覆盖过的方法运行。

 

 

类型的转换：转换编译时类型

Sub su＝（sub）s;

子类型的引用向父类型转换时，不需要强转

父类型的引用向子类型转换时，需要强转

 

Animal a=new cat()

Dog b=(dog)a——类型异常转换

 

引用 Instanceof 类名——》boolean

引用所指向的对象和类名所代表的类型是否一致

A instanceof animal    true

A instanceof cat      true

A instanceof dog     false

 

用父类型屏蔽子类对象的差异

 

Static

Static 修辞 变量：

    类的所有对象共同拥有的一个属性，也称为类变量，

             跟类创建了多少对象无关

             可以用类名直接访问，不需要对象

             任何对象对静态变量做修改，其他对象看到的是修改后的值

             可以用作计数器，记录类创建对象的个数     

             在类加载的时候初始化，初始化一次

类加载：jvm在第一次使用一个类时，会根据classpath所指定的路径里去找这个类所对应的字节文件，并读进jvm保存起来，这个过程称之为类加载。

Static修辞  方法：

     类的所有对象共同拥有的一个功能

     跟类创建了多少对象无关

     可以用类名直接访问，不需要对象，所以能直接访问

（在没有对象的情况下）实例变量，在静态方法里不能出现this或者super

 

 

Static修辞 初始化块 ：

                   用static修饰类里面的一个独立的代码块

                   类第一次加载时候执行，执行一次。

 

 

 

有static修辞的变量，初始化块，在类加载时初始化。

 

 

 

 

 

先父后子，先静后实例。

 

Final

 

    类：该类不能被继承，不能被继承意味着不能改变里面的代码

     对虚拟机的正常运行有重要作用的类通常是final的，如String math System

    方法：该方法不能被覆盖。但是可以继承

  

    变量：Final 修辞的变量就是常量，通常final和static连用来声明常量。

         Final修饰应用类型数据，指引用（地址）不能变，内存里的真正数据不受限制。

   Final修饰的实例变量：声明的同时赋值，或者构造方法里赋值,只能选择一种

   Final修饰的静态变量。声明的同时赋值，或者在静态初始化块在赋值

    final修饰的变量就是常量，通常final和static连用来声明

 

Private修辞的方法也不能被覆盖。是不能继承

 

――――――――――――――――――――――――――――――――――――

 

Abstract

  类：抽象类，不能手动创建对象。不能创建对象，但是可以声明抽象类型的引用

  方法：抽象方法，只有方法名的定义，没有实现，（只定义了能做什么，没有说明怎么做。）

抽象方法允许方法的定义和实现分开。

 

含有抽象方法的类一定是抽象类，抽象类不一定有抽象方法。

抽象是用来被继承，说明类的共性，给出功能的定义。

 

抽象类用来被继承，子类继承抽象类，就要实现里面的抽象方法，如果不想让子类也是一个抽象类，就必须实现抽象类里的所有的抽象方法。

 

多态时使用抽象类

可以声明父类类型子类对象 ，利用多态调用抽象方法。

 

抽象类有构造方法，只有jvm才能创建抽象类的对象。         Jvm表示虚拟机

Abstact 不能修辞属性。

抽象类可以继承其它类，抽象类可以有父类，也遵循单继承的规律。

 

Public   Private   Default  Static    Final    Abstract

可以：

Public static

Private static

Public final

Public static final

 

不可以：abstract final void eat()

        Private abstract void eat()

        Static abstract void eat()

       

Abstract 不能和private、final、static连用。