程序员_Java基础<一>-面向对象上

 

涉及内容：

定义、封装、构造函数、构造代码块、this、super、静态static、静态代码块、继承、覆盖、final

1、
特征:封装,继承,多态
思想:找对象,建立对象,使用对象,维护对象的关系.
类和对象的关系:类就是对现实生活中事物的描述.
对象:就是这类事物,实实在在存在个体.
2、

对象定义:
如 Car c= new Car();//其中Car是一个类，c为类类型的变量，即对象。
成员变量和局部变量：
成员变量：a.作用于整个类中,b.在堆内存中，因为对象的存在，才在内存中存在。
局部变量：a作用于函数中，或语句中。b存在栈内存中。
匿名对象：new Car();
使用方式一：当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化。
    如果对一个对象进行多个成员调用，必须给这个对象起名字。
使用方式二：可以将匿名对象作为实际参数进行传递。

3、
封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
好处：将变化隔离，便于使用，提高重用性，提高安全性。
封装原则：a将不需要对外提供的内容都隐藏起来。
  b把属性都隐藏，提供公共方式对其访问。
例如在建立一个包含性别，年龄，学历等的Person类时，将性别，年龄，学历设为private。
private :私有，权限修饰符：用于修饰类中的成员（成员变量，成员函数 ）。私有只在本类中有效。
解释：在类中将成员私有话之后，类以外即使建立了对象也不能直接访问，即使子类也不行。
注意：私有仅仅是封装的一种表现形式
之所以对外提供访问方式，仅因为可以在访问方式中加入逻辑判断等语句。对访问的数据进行操作。提高代码健壮性。
4、
构造函数：
1.函数名与类名相同。
2.不用定义返回值类型。
3.不可以写return语句。
对象一建立（即new（）时），就会调用与之相对应的构造函数。
什么时候定义构造函数？
当分析事物是，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。
构造函数的作用：可以用于给对象进行初始化。
注意：当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。当在类中自定义了构造函数后，默认的构造函数就没有。

构造函数和一般函数在写法上有不同。
在运行上也不同。构造函数是在对象一建立，就给对象初始化。
而一般方法是对象调用才执行，是给对象添加对象具备的功能。
一个对象建立，构造函数只运行一次。
而一般方法可以被该对象调用多次。

5.
构造代码块：
格式：{
………….
      }
作用：给对象进行初始化。一般把所有对象的共性部分写在这就行初始化。
对象一建立就运行，而且优于构造函数执行。
和构造函数的区别：
构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化。
6.

this关键字：
this代表本类的对象，this代表它所在函数所属对象的引用，即哪个对象在调用this所在的函数，this就代表哪个对象。
this.**中的**代表this所代表的对象的对应属性。

this的应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。
即谁调用this所在函数，this就代表谁。

this关键字在构造函数间调用：
构造函数间调用只能用this关键字，类似函数间的传值调用。
 注意：this只能在构造函数的第一行。因为初始化动作要先执行。
实例：

class Person{private String name;private int age;Person(String name){this.name=name;}Person(String name,int age){this(name);//此处就是this在构造函数间的调用，函数将name传到上一个构造函数中进行初始化，注意this后没有.this.age=age;}}

7、
static 关键字：即类变量
是一个修饰符，用于修饰成员（包括成员变量，成员函数。）
当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以被类名调用

格式：类名.静态成员。
注意：非static成员只能由对象调用。
static特点：1，随着类的加载而加载。也就是说静态会随着类的消失而消失。而非static成员变量当类加载时还不存在。
    2优先于对象存在。即静态时先存在，对象后存在。
    3.被所有对象共享。
    4.可以直接被类名所调用。
实例变量和类变量区别：
1 存放位置：
类变量随着类的加载而存在于方法区中。
实例变量随着对象的建立而存在于堆内存中。
2.生命周期：
类变量生命周期最长，随着类的消失而消失、
实例变量生命周期随着对象的消失而消失。

静态使用注意事项：
1，静态成员只能访问静态成员，不能访问非静态成员。
2，非静态方法既可以访问静态也可以访问非静态。
3，静态方法中不可以定义this，super关键字。
4，因为 静态优于对象存在，所以静态方法中不可以出现this
5，主函数一定是静态的
主函数：public static void main(String[] args)
是一个特殊的函数，作为程序的入口，可以被jvm调用。
主函数的定义：
public：代表着该函数访问权限是最大的。
static：代表主函数随着类的加载就存在了。
void：主函数没有具体的返回值。
main：不是关键字，但是一个特殊的单词，可以被jvm识别。
（String[] args）:函数的参数，参数类型是一个数组，该数组中元素是字符串，字符串类型的数组。
主函数是固定格式的：jvm识别。 
 jvm在调用主函数时，传入的是new String[0]

6、

需要注意的一点：static绝对不能修饰局部变量。

<strong><span style="font-family:KaiTi_GB2312;font-size:18px;color:#333333;">局部变量的作用域就是它所在的方法或代码块中，而static的变量刚是定义在类中方法体外，是作为整个类共同使用的，它从类加载开始就存在，而局部变量在它所在的方法或代码块结束后就要被回收的。所以是不能修饰局部变量的</span></strong>

静态有利有弊：
利处：对对象的共享数据进行单独空间的存储，节省空间。没有必要对每一个对象中都存储一份。
可以直接被类名调用。
弊端：生命周期过长，访问出现局限性。（静态虽好，只能访问静态）

什么时候用静态static：
从两方面:
因为静态修饰的内容有成员变量和函数。
什么时候定义静态变量（类变量）呢：
当对象中出现共享数据时（如在中国定义Person时，国籍即为静态的），该数据被静态所修饰。
对象中的特有数据要定义成非静态，存在于对象内部。

什么时候定义静态函数？
*重要*当功能内部没有访问到非静态数据（对象的特有数据），那么该功能可以定义为静态的。

静态的应用-工具类：
每一个应用程序中（每个类）中都有共性的功能，可以将这些功能进行抽取，独立封装，一边复用。

当使用这次工具方法时，我们发现：
1，对象是用于封装数据的，可是工具类创建的对象并未封装特有数据。
2，对每一个方法也没有用到工具对象中的特有数据。
3，综上考虑，让程序更严谨，是不需要对象的。于是可以将工具类中的方法都定义成static的，直接通过类名调用即可，就不用使用对象了。
在将方法都设成静态后，可以方便使用，但是该类还是可以被其他程序建立对象的。为了更为严谨，于是强制让该类不能建立对象，可以通过将构造函数，设为private，私有化后就不能在类中建立对象了。
8、

制作帮助文档
  (1)帮助文档就是类的说明书，可帮助更好地使用类和程序。
  (2)制作帮助文档使用的是javadoc.exe工具
  F：\haima>javadoc -d myhelp -author -version ArrayTool.java
  (3)注：
  <1>凡是public修饰的功能都用文档注释来描述，因为都可以被文档注释工具所提取。
  <2>只有public和protect修饰的类才可被提取生成文档。
  <3>类中默认的构造函数的权限和所属类一致。且默认构造函数的权限是随着
   类的变化而变化的。

/**
@auther 张三
@version 1.1
……
*/

9、

静态代码块：
static 
{
}
随着类的加载而执行，且只执行一次，并优先于主函数。用于给类进行初始化。
注意：静态代码块是给类进行初始化的，在加载类时加载。
      而代码块是给对象进行初始化的，在创建对象时加载。
对象的初始化过程：
Person p =new Person（“张三”，20）；
该句话都做了什么事情？
1.因为new用到了Person.class,所以会找到Person.class文件并加载到内存。
2.执行该类中的static代码块，如果有的话，给Person.class类进行初始化。
3.在堆内存中开辟空间，分配内存地址。
4.在堆内存中建立对象的特有属性，并进行默认初始化。
5.对属性进行显示初始化。
6.对对象进行构造代码块初始化。
7.对对象进行对应的构造函数的初始化。
8.将内存地址赋给栈内存中的p变量。
10.
继承：extends
例如：class Student extends Person
1.提高了代码的复用性。
2.让类与类之间产生关系，有了这个关系，才有了多态的特性。
注意：千万不要为了获取其他类的功能，简化代码而继承。必须是类与类之间所属关系才可以继承。
注意：1.Java语言中，java只支持单继承，不支持多继承。
      因为多继承容易带来安全隐患：当多个父类中定义了相同功能，当功能内容不同时，子类不知道要执行哪个。
      2.但Java保留了这种机制，并用了另一种体现形式来完成表示，即多实现。
      3.Java支持多层继承。也就是一个继承体系。
   如何使用一个继承体系中的功能呢？
先查阅体系父类的描述，因为父类中定义的是该体系中共性功能。
通过了解共性功能，就可以知道该体系的基本功能。
那么这个体系已经可以基本使用了。
注意：那么在具体调用时，要创建最子类的对象，为什么呢？
1.因为有可能父类不能创建对象。
2.创建子类对象可以使用更多的功能，包括基本的也报考特有的。
简单一句话：查阅父类功能，创建子类对象使用功能。
子父类出现后，类成员特点：
类中成员：
1变量：如果子类中出现非私有的同名成员变量时，子类要访问本类的变量，用this，子类要访问父类中的同名变量，用super。
super的使用和this的使用几乎一致。
this代表的是本类对象的引用。
super代表的是父类对象的引用。

class Fu{int num=4;}class Zi extends Fu{int num=5;void show(){System.out.println(super.num);//super即超类即父类，与this相对。}}class  Single{public static void main(String[] args) {Single ss=Single.getInstance();}}

11.

覆盖：当子类出现和父类一模一样的函数时，当子类对象调用该函数，会运行子函数的内容。
如同父类的函数被覆盖一样。
这种情况是函数的另一个特性：重写（覆盖）。
当子类继承了父类，沿袭了父类的功能，到子类中，但是子类虽具备该功能，
但是功能的内容去和父类不一致，这是，没必要定义新功能，而是覆盖父类的功能定义，并重写功能内容。
注意：1.子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。
2.静态只能覆盖静态，因为若父类是非静态时，没创建对象时是不能访问非静态的
而重载：只看同名函数的参数列表。
重写即覆盖：子父类方法要一模一样。

过程：
在对子类对象进行初始化时，父类的构造函数也会进行，因为子类的构造函数
默认第一行有一条隐式的语句super（）；
super（）：会访问父类中空参数的构造函数，而且子类中所有的构造函数默认第一行都是super（）；
注意：这个隐式的语句是super（），而不会出现父类的其他构造函数，例如super（int x）等等。

为什么子类一定要访问父类中的构造函数?
    因为父类中的数据,子类可以直接 获取，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始       化的。
    如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。
注意：1，super语句一定定义在子类构造函数的第一行。
      2.子类的所有构造函数，默认多会访问父类中空参数的构造函数，因为子类每一个构造函数的第一行 都有一       句隐式super（）；
      3.当父类中没有空参数的构造函数时，在子类中一定要通过super（）或this（）的形式手动指定要访问的父        类中的构造函数，如super（int x）
      4.当然，子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。只要保证子类 中至少会有一个构造函数会访问父类的构造函数。
实例代码：

class Fu{int num;Fu(){num=60;System.out.println("fu run");}Fu(int x){System.out.println("fu..."+x);}}class Zi extends Fu{Zi(){//super();//super(int x);}Zi(int x){this();//注意此处，this（），super（），不能同时出现，只能写其中一个。System.out.println("zi..."+x);}}class ExtendsDemo4{Zi z=new zi(0);System.out.println(z.num);}

12.

final关键字：最终。
1.作为一个修饰符，可以修饰类，函数，变量。
2.被final修饰的类不可以被继承。为了避免被继承，被子类复写功能。
3.被final修饰的方法不可以被复写。
4.被final修饰的变量是一个常量，只能赋值一次，既可以修饰成员变量，也可以修饰局部变量。
当在描述事物是，一些数据的出现值是固定的，那么为了增强阅读性，都给这些值起个名字，方便阅读，
而这个值不需要改变，加上final。

作为常量：常量的书写规范，所以字母都大写，如果由多个单词组成，单词间通过_连接。

5.内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。（以后介绍）