黑马程序员 Java面向对象及类特性

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

 

面向对象三个特征：封装，继承，多态。

映射到Java中，描述就是class定义的类，具体对象就是对应Java在堆内存中用new建立实体。

car c =new car c;   //c就是一个类类型变量，记住：类类型变量指向对象。

成员变量和局部变量：

作用范围：成员变量作用于整个类中。局部变量作用于函数中或者语句中。

在内存中的位置：成员变量，在堆内存中，因为对象的存在才在内存中存在。局部变量，存在栈内存中。

private：私有，权限修饰符，用于修饰类中的成员（成员变量，成员函数），私有只在本类中有效。

构造函数特点：

1.函数名与类名相同。

2.不用定义返回值类型。

3.不可以写return语句。

作用：给对象进行初始化。

注意：1，默认构造函数的特点。2，多个构造函数是以重载的形式存在的。

对象一建立就会调用与之对应的构造函数。构造函数的作用：可以用于给对象进行初始化。当一个类中没有定义构造函数时那么系统会默认给该类加入一个空参数的构造函数。

构造函数与一般函数在写法上有不同，在运行上也不同：构造函数是在对象一建立就运行，给对象初始化，而一般方法是对象调用才执行，给对象添加对象具备的功能。

一个对象建立，构造函数只运行一次，而一般方法可以被该对象调用多次。

什么时候定义构造函数：

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

构造代码块：作用给对象进行初始化，对象一建立就运行，而且优先于构造函数执行。和构造函数的区别：构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化。

this关键字

this表示当前对象，而所谓的当前对象就是指调用类中方法或属性的那个对象。

构造函数的调用，this只能放在构造函数的第一行。

class Person{    private String name;    private int age;    public Person(String name,int age){        this.name=name;        this.age=age;    }}

static关键字：

静态修饰符内容被对象所共享，不占用堆内存。当用static修饰后多了一种新的调用方式：类 . 静态成员。

特点：1，随着类的加载而加载。2.被所有对象共享。3.优先于对象存在。4.可直接被类名调用。

实例变量和类变量的区别：

1.存放位置：类变量随着类的加载而存在于方法区中。实例变量随着对象的建立而存在于堆内存中。

2.生命周期：类变量生命周期最长，随着类的消失而消失。实例变量生命周期随着对象的消失而消失。

静态的使用注意事项：

1.静态方法只能访问静态成员（方法/变量），非静态方法既可以访问静态也可以访问非静态。

2.静态方法中不可以定义this/super关键字，因为静态优先于对象存在，所以静态方法中不可以出现this。

3.主函数是静态的。

利：对象的共享数据单独空间的存储，节省空间，没有必要每一个对象中都存储一份，可以直接被类名调用。

弊：生命周期长，访问出现局限性（静态只能访问静态）。
主函数：是一个特殊的函数作为程序的入口，可以被jvm调用。

主函数的定义：

public：代表着该函数访问权限是最大的。

static：代表主函数随着类的加载就已经存在了。

void：主函数没有具体的返回值。

main：不是关键字，但是一个特殊的单词，可以被jvm识别。

（String[] args）：函数的参数，参数类型是一个数组，该数组中的元素是字符串，字符串类型的数组。

静态代码块：

static{

静态代码块中的执行语句；

}

特点：随着类的加载而执行，只执行一次，用于给类进行初始化，优先于主函数。

class StaticCode{static{System.out.println("a");}}class StaticCodeDemo {static{System.out.println("b");}public static void main(String[] args) {new StaticCode();new StaticCode();System.out.println("over");}static{System.out.println("c");}}

结果为：b  c  a  over

Person p=new person("zhangsan",20);

1.因为new用到了Person.class，所以会先找到Person.class文件并加载到内存中。

2.执行该类中的static代码块如果有的话给Person.class进行初始化。

3.在堆内存中开辟空间，分配内存地址。

4.在堆内存中建立对象的特有属性，并进行默认初始化。

5.对属性进行显示初始化。

6.对对象进行构造代码块初始化。

7.对对象进行对应的构造函数初始化。

8.将内存地址付给栈内存中的p变量。

设计模式：解决某一类问题最行之有效的方法。

单例设计模式：解决一个类在内存只存在一个对象。

1.为了避免其他程序过多建立该对象，先禁止其他程序建立该对象。

2.还为了让其他程序可以访问到该对象，只好在本类中，自定义一个对象。

3.为了方便其他程序对自定义对象的访问，可以对外提供一些方式。

饿汉式：

class Single{private int num;public void setNum(int num){this.num=num;}public int getNum(){return num;}private Single(){}private static Single s=new Single();public static Single getInstance(){return s;}}class StaticCodeDemo {public static void main(String[] args) {Single s1=Single.getInstance();Single s2=Single.getInstance();s1.setNum(23);System.out.println(s2.getNum());}}

懒汉式（部分代码）：

class Single{private static Single s =null;private Single(){}public static Single getInstance(){if(s==null)s=new Single();return s;}}

类的继承：Java中支持类的单继承和多层继承，但不支持多继承，即一个类只能继承一个类而不能继承多个类。

Java继承只能直接继承父类中的公有属性和公有方法，而隐含的（不可见）继承了私有属性。

1.子类覆盖父类必须保证子类权限大于等于父类权限才可以覆盖，否则编译失败。

2.静态只能覆盖静态。

这里要分清重载与重写：

重载：只看同名函数的参数列表。

重写：子父类方法一摸一样。
在对子类对象进行初始化时，父类的构造方法也会运行，那是因为子类的构造函数默认第一行有隐式super（），会访问父类中空参数的构造函数，而且子类中所有的构造函数默认第一行都是super（）。

注意：super语句一定要定义在子类构造函数的第一行。

子类的实例化过程：

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

final：最终，作为一个修饰符。

1.可以修饰类，函数，变量。

2.被final修饰的类不可以被继承，避免子类重写。

3.被final修饰的方法不能被重写。

4.被final修饰的变量是一个常量，只能赋值一次，既可以修饰成员变量，也可以修饰局部变量。

当在描述事物时，一些数据的出现时固定的，那么这时为了增强阅读性，都给这些值起个名字，方便于阅读，而这个值不需要改变，所以加上final修饰，作为常量。

abstract抽象关键字：

1.抽象方法需定义在抽象类中。

2.抽象方法，抽象类必须被abstract修饰。

3.抽象类不可以用new创建对象，因为调用抽象方法没意义。

4.抽象类中的方法要被使用必须由子类重写所有的抽象方法后建立子类对象调用，如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。