黑马程序员-Java基础知识4,（部分笔记总结面向对象-类）

1.类

1）是同类型东西的概念，是对现实生活中事物的描述，映射到Java中描述就是class定义的类。类是对象的模板、图纸，是对象的数据结构定义。简单说就是“名词”。

2）其实定义类，就是在描述事物，就是在定义属性（变量）和方法（函数）。

3）类中可以声明：属性，方法，构造器；属性（变量）分为：实例变量，局部变量；实例变量：用于声明对象的结构的，在创建对象时候分配内存，每个对象有一份！实例变量（对象属性）在堆中分配，并作用于整个类中，实例变量有默认值，不初始化也能参与运算；局部变量在栈中分配，作用于方法或语句中，必须初始化，有值才能运算。

4）类与类之间的关系：①关联：一个类作为另一个类的成员变量：需要另一个类来共同完成。class A { pulic B b }       class B {}       ②继承：class B extends A {}      class A {}          ③依赖：个别方法和另一个类相关。class A {    public void f(B b) {}//参数里有B              public B g() {}//返回值里有B }  class B {}

5）null与空指针异常：引用类型变量用于存放对象的地址，可以给引用类型赋值为null，表示不指向任何对象。当某个引用类型变量为null时无法对对象实施访问（因为它没有指向任何对象）。此时，如果通过引用访问成员变量或调用方法，会产生NullPointerException空指针异常。

       注意事项：除了8中基本类型，其他都是引用类型变量（也叫句柄）。

2。对象

是这类事物实实在在存在的个体！利用类做为模板创建的个体实例，本质是数据。

匿名对象：使用方式一：当对对象的方法只调用一次时，可用匿名对象来完成，这样比较简化。如果对一个对象进行多个成员调用，则必须给这个对象起个名字。

  使用方式二：可以将匿名对象作为实际参数进行传递。

3.包

1）包名必须是小写，多个单词用“．”隔开。在同一个包中，不能有同名的类！

2）只要在同一个包中，则可直接用extends（类型互知道在哪），若不在同一个包中，则用import导入。

4.方法及其调用
是用于对当前对象数据进行算法计算，实现业务功能。方法是对象的功能，对象的动作，对象的行为。总之是动词！方法名没有规定，建议首单词为小写动词，其他单词首字母大写。必须定义返回值！可有无参数方法。方法调用只有两种方式：①对象引用调用②类名调用（即静态类时）。

5.访问控制（封装）

封装：将数据封装到类的内部，将算法封装到方法中。

1）封装原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问，通常有两种访问方式：set 设置，get 获取。

2）封装结果：存在但是不可见。

3）public：任何位置可见，可以修饰：类、成员属性、成员方法、内部类、跨包访问类（需要使用import语句导入），成员属性 = = 成员变量。

4）protected：当前包中可见，子类中可见。可以修饰：成员属性、成员方法、内部类（只能在类体中使用，不能修饰类）。

5）默认的：当前包内部可见，就是没有任何修饰词，可以修饰：类、成员属性、成员方法、内部类，但在实际项目中很少使用。默认类（包内类）的访问范围：当前包内部可见，不能在其他包中访问类，访问受限！main方法若定在默认类中JVM将找不到，无法执行，因此必定在public类中。

6）private：仅仅在类内部可见。可以修饰：成员属性、成员方法、内部类（只能在类体中使用，不能修饰类）。私有的方法不能继承，也不能重写。

       注意事项：在企业项目中建议：所有类都是公用类。封装的类使用内部类！

6.重载和重写

1）重写：通过类的继承关系，由于父类中的方法不能满足新的要求，因此需要在子类中修改从父类中继承的方法叫重写（覆盖）。

①方法名、参数列表、返回值类型与父类的一模一样，但方法的实现不同。若方法名、参数列表相同，但返回值类型不同会有变异错误！若方法名、返回值类型相同，参数列表不同，则不叫重写了。

②子类若继承了抽象类或实现了接口，则必须重写全部的抽象方法。若没有全部实现抽象方法，则子类仍是一个抽象类！

③子类重写抽象类中的抽象方法或接口的方法时，访问权限修饰符一定要大于或等于被重写的抽象方法的访问权限修饰符！

④静态方法只能重写静态方法！

2）重载：方法名一样，参数列表不同的方法构成重载的方法（多态的一种形式）。

①调用方法：根据参数列表和方法名调用不同方法。

②与返回值类型无关。

③重载遵循所谓“编译期绑定”，即在编译时根据参数变量的类型判断应调用哪个方法。  eg：重载

           int[] ary1 = {'A','B','C'};         char[] ary2 = {'A', 'B', 'C'};

      System.out.println(ary1);//println(Object)

//按对象调用，结果为地址值，没有println(int[])

             System.out.println(ary2);//println(char[])  ABC

              System.out.println('中');//println(char)    中

              System.out.println((int)'中');//println(int)  20013

7.

继承

父子概念的继承：圆继承于图形，圆是子概念（子类型 Sub class）图形是父类型（Super Class也叫超类），继承在语法方面的好处：子类共享了父类的属性和方法的定义，子类复用了父类的属性和方法，节省了代码。

1）继承是is a ：“是”我中的一种，一种所属关系。

2）子类型对象可以赋值给父类型变量（多态的一种形式），变量是代词，父类型代词可以引用子类型东西。

3）继承只能是单继承，即直接继承，而非间接继承。因为多继承容易带来安全隐患，当多个父类中定义了相同功能，当功能内容不同时，子类无法确定要运行哪一个。

4）父类不能强转成子类，会造型异常！子类向父类转化是隐式的。

5）只有变量的类型定义的属性和方法才能被访问！见下例。

6）重写遵循所谓“运行期绑定”，即在运行的时候根据引用变量指向的实际对象类型调用方法。

eg：Shape s，s只能访问Shape上声明的属性和方法

                     Circle c = new Circle(3,4,5);

                     Shapes = c;//父类型变量s引用了子类型实例

                     //s和 c引用了同一个对象new Circle(3,4,5)

                    s.up();        System.out.println(c.r);

                     System.out.println(c.area());

                     //System.out.println(s.area());//编译错误

                     //System.out.println(s.r);//在Shape上没有定义r属性！

7）引用类型变量的类型转换 instanceof

       publicstatic void main(String[] args) {

              Circle c = new Circle(3,4,5);              Rectr = new Rect(3,4,5,6);

              Shape s = c;           Shape s1 = r;

              //Circle x = s;//编译错误，父类型变量不能赋值给子类型

              Circle x = (Circle)s;//正常执行

              //Circle y = (Circle)s1;//运行异常,类型转换异常

              //instaceof instace：实例 of:的

              //instaceof 运算 检查变量引用的对象的类型是否兼容

              //s引用的是圆对象，s instanceof Circle 检查s引用的对象是否是Circle类型的实例！

              System.out.println(s instanceofCircle);//true

              System.out.println(s1 instanceofCircle);//false

              test(c);           test(r);           }

       publicstatic void test(Shape s){//多态的参数

              //if(s instanceof Circle)保护了(Circle)s不会出现异常

              if(s instanceof Circle){//实现了安全的类型转换

                     Circlec = (Circle) s;  System.out.println("这是一个圆, 面积"+c.area());     }

              if(s instanceof Rect){

                     Rectr = (Rect) s;    System.out.println("这是一个矩形, 面积"+r.area()); }          }

8）继承时候对象的创建过程

①Java首先递归加载所有类搭配方法区。②分配父子类型的内存（实例变量）。③递归调用构造器。

9）重写方法与重载方法的调用规则

10）属性绑定到变量的类型，由变量类型决定访问哪个属性；方法动态绑定到对象，由对象的类型决定访问哪个方法。（强转对方法动态绑定到对象无影响，因为强转的是父类的引用，而实例是没变的，只是把实例当作另一个状态去看而已。但是强转对属性动态绑定到变量类型有影响。）其他解释请看多态部分！

eg1：方法动态绑定到运行期间对象的方法 实例1

eg2：方法动态绑定到运行期间对象的方法 实例2

11）为何查阅父类功能，创建子类对象使用功能？

Java中支持多层继承，也就是一个继承体系。想要使用体系，先查阅父类的描述，因为父类中定义的是该体系中共性的功能，通过了共性功能，就可以知道该体系的基本功能，那么这个体系已经可以基本使用了，然而在具体调用时，要创建最（低）子类的对象，原因如下：①因为父类有可能不能创建对象②创建子类对象，可以使用更多的功能，包括基本的也包括特有的。

12）属性无继承概念，所以你有你的，我有我的，各自调用各自的，不影响，即使子父类中有同名属性也无影响。

eg：子父类同名属性无影响

  class Base {  public static finalString FOO="foo";  publicstatic void main(String[] args){

            Base b=new Base();      Sub s=new Sub();

            Base.FOO;//foo     b.Foo; //foo    Sub.Foo;//bar     s.Foo;//bar

           ( (Base) s . Foo);// foo                                }        }

   class Subextends Base{  public static final StringFOO="bar";  }