Java基础知识小结 三 （自学）

                                                                        面向对象的思想                   


1.面向对象是相对面向过程而言?
2.面向对象和面向过程都是一种思想?
面向过程
   强调的是功能行为
面向对象
   将功能封装进对象，强调具备了功能的对象。
面向对象是基于面向过程的。


面向对象的思想：
    把一头大象装进冰箱，首先打开冰箱，然后把大象存储进去，然后关闭冰箱。
然而打开，存储，关闭都是冰箱的属性。把打开，存储，关闭三个属性封装进冰箱这个功能里，只要操作冰箱这个事物就是在操作打开，存储，关闭。所以，就变成了      冰箱.打开------>冰箱.存储------>冰箱.关闭




                            类和对象的关系


java中描述事物通过类的形式体现，类是抽象的概念。
类：对现实生活中事物的描述。
对象：就是这类事物具体的个体。


可以理解为：
  类就是图纸
  汽车就是堆内存中的对象


Java中用类class来描述事物
   属性：对应类中的成员变量。
   行为：对应类中的成员函数。
定义类其实在定义类中的成员(成员变量和成员函数)。




                        成员变量和局部变量


成员变量：
1. 成员变量定义在类中，在整个类中都可以被访问。
2. 成员变量随着对象的建立而建立，存在于对象所在的堆内存中。
3. 成员变量有默认初始化值。


局部变量：
1. 局部变量只定义在局部范围内，如：函数内，语句内等。
2. 局部变量存在于栈内存中。
3. 作用的范围结束，变量空间会自动释放。
4. 局部变量没有默认初始化值。必须赋初始化值才能参与运算。


例子：
class Car//对Car这类事物进行描述
{
String color = "red";
int num = 4;
void show()
{
System.out.println("color="+color+"..num="+num);
}
}
class CarDemo
{
public static void main(String[] args)
{
Car c = new Car();  //建立对象
c.color = "black";  //对对象的属性进行修改
c.show();   //使用对象的功能。
}
}




                          匿名对象


一，对象可以起名字，也可以不起名字。匿名对象就是没有名字的对象。


二，匿名对象两种使用情况：
    1.当对对象方法仅进行 一次调用的时可以使用匿名对象，要是对多个对象进行调用，就必须给这个对象起个名字。
class  carDemo
{
public static void main(String[] args) 
{
Car c = new Car();
c.run();
new car().run();   //匿名对象
}
}




2. 匿名对象可以作为实际参数进行传递
例子：
class  carDemo
{
public static void main(String[] args) 
{
show(new Car());  //匿名对象作为实际参数传递
}
public static void show(Car c)
{
c.num;
c.color = "black";
c.run;
}
}




                    封装(Encapsulation)


封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
?
好处：
1.将变化隔离。
2.便于使用。
3.提高重用性。
4.提高安全性。
?
封装原则：
1.将不需要对外提供的内容都隐藏起来。
2.把属性都隐藏，提供公共方法对其访问。




                        构造函数


特点：
1.函数名和类名相同。
   对象一建立就会调用已经建立的构造函数。
2.不用定义返回值类型。
3.不可以些return语句。


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


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


构造函数的小细节：
1.当一个类中没有定义构造函数，那么系统就会给类加入一个空参数的构造函数。
2.当在类中如果定义了构造函数，默认的构造函数就没有了。


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


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




                          构造函数代码块


作用：
1.给对象的数据进行初始化
2.对象一建立就运行，优先于构造函数执行。


例子：
class  Person 
{
private String name;
private int age;
//构造函数代码块
{
System.out.println("Hello World!")
}


public static void main(String[] args) 
{
Person p = new Person();


}
}


和构造函数的区别：
1.构造代码块是给所有对象统一初始化。而构造函数是给对应的函数分别初始化。
2.构造代码块里边定义的是，所有不同对象共性的初始化内容。




                         this关键字


this是Java中的一个关键字，可以出现在实例方法和构造函数中，但是不可以出现在类方法中。
1.在构造方法中使用this
    在构造方法中使用，代表使用该构造方法所创建的对象。
2.在实例方法中使用this
    可以出现在实例方法中，实例方法可以操作成员变量，所以当this出现在实例方法中时，代表使用该方法的当前对象。
3.类方法(静态方法)中不可以使用this
4.this：用于区分局部变量和成员变量同名情况。
5.this：代表它所在函数所属对象的引用。


1.this语句(this(name)):this 后边直接加个括号，不用写“.”。用于构造函数之间互相调用。
2.this语句只能放在构造函数的第一行。因为初始化动作要先执行。




                         static关键字 


1.用法：是一个修饰符，用于修饰成员(成员变量，成员函数)。当成员被静态修饰后，可以被对象调用外，还可以直接被类名调用。  格式：类名.静态成员(变量和方法)


例子：
class Person
{
String name;  //成员变量，实例变量
static String country = "CN";  //静态变量，类变量
public void show()
{
System.out.println("Hello World!");
}
public static void main(String[] args) 
{

//类名.静态成员
System.out.println(Person.country);
}
}




static的特点：
1.随着类的加载而加载。
    当一个类被加载进内存时，静态成员也就跟着被加载进内存了。静态会随着类的消失而消失。所以它的生命周期最长。
2.优先于对象存在。
    对象只有被调用的时候才会存在，而静态成员是随着类就加载的。所以静态优先于对象存在。 
3.静态修饰的成员被所有对象所共享。
4.可以直接被类名所调用。特有数据随着对象存储。


实例变量和类变量区别：
1.存放位置
    类变量随着类的加载而存放在方法区中。
    实例变量随着对象的建立而存放在堆内存中。
2.生命周期
    类变量生命周期最长，随着类的消失而消失。
    实例变量生命周期随着对象的消失而消失。


静态使用注意事项：
1.静态方法只能访问静态成员。
    非静态方法既可以访问静态的也可以访问非静态的。
2.静态成员中不可以定义this,super关键字。
    因为静态优先于对象存在，所以静态方法中不可以出现this.
3.主函数是静态的。


静态的利弊：
利：
1.对对象的共享数据进行单独空间的存储，节约空间。
2.可以直接被类名调用。
弊：
1.生命周期过长。
2.访问出现局限性。


                           
                            main函数


public static void main(String[] args) 


主函数：是一个特殊的函数。作为程序的入口，可以被jvm调用。
主函数的定义：
public：代表着函数访问权限是最大的。
static：代表着主函数随着类的加载就已经存在了。
void：主函数没有具体的返回值。
main：不是关键字，但是是一个特殊的单词，可以被jvm识别。
(String[] args) ：函数的参数类型是一个数组，该数组的元素是一个字符串。字符串类型的数组。


主函数的格式是固定的。除了 args.
引用数据类型要么为空，要么就是一个具体的数值。




                            
什么时候使用静态


要从两个方面入手：
因为静态修饰的内容有成员变量和函数。所以从这两个方面入手。


什么时候定义静态变量？
当对象中出现共享数据时，该数据被静态所修饰。
对象中的特有数据要定义成非静态存在于堆内存中。


什么时候定义静态函数？
当功能内部没有访问到非静态数据(对象的特有数据)
那么该功能可以定义成静态的。




静态的应用


    每一个应用程序中都有共性的功能，可以将这些功能进行抽取，独立封装以便复用.
    虽然可以通过建立ArrayTool的对象使用这些工具方法，对于数组进行操作。但是在操作的过程中发现了问题：
1.对象是用于封装数据的，但是ArrayTool对象并未对封装特有数据。
2.操作数组的每一个方法都有没有用到ArrayTool对象中的数据。


  为了使程序更加严谨，不需要建立对象。可以将ArrayTool中的方法都定义成static的，直接通过类名调用即可。


    将方法都静态以后，可以方便使用，但是该类还是可以被其他程序建立对象，为了让程序更加严谨，强制让该类不能建立对象，可以通过把构造函数私有化。
       
小知识点：
假如把运行文件转移到了另一个地址，那么再编译的时候就会编译不通过，这是就需要使用set命令:  
格式：set classpath=.;c:\Demo(运行文件转移后的地址); 
//其中“.”是当前目录的意思，现在当前寻找，找不到再去转移后的地址。




帮助文档的制作javadoc


为什么要制作Javadoc？
   当把这个运行文件发送给其他人的时候，这个人不知道这个运行文件到底有什么功能，多少个方法。javadoc就是这个运行文件的说明书。


    开始制作程序的说明书，Java说明的书通过文档注释来完成。就是把所写的程序都用文档注释来注释一下。
    1.首先书写整个程序的文档注释，比如这个程序是一个什么类，提供了什么方法，作者是谁，版本号是多少。有些特殊符号是可以被文档注释直接提取的比如“@”。    @author  //作者       @version    //版本
    2.整个类的文档注释注释完后，然后再注释各个功能，每一个被public修饰的都用文档注释，引文可以被文档注释直接提取。
    3.文档注释写完后，要用一个工具进行提取，提取出文档注释。javadoc.exe
在DOS窗口中的命令：


例子：
javadoc -d mydocument -version -author ArrayTool.java
//-d 其中个d是directory目录的意思。
//mydocument 是文件夹名，如果没有这个文件夹，系统会自动添加一个；
//-version -author 是版本和作者，也可以不写。
//ArrayTool 是类名


注意：
    要想把一个类，提取成帮助文档，这个类必须是public，不然编译是不能通过的。当文件生成后，就会在mydocument文件夹里生成许多网页文件。打开index这个网页文件就可以了。
    这个网页上提供的是这个类封装的对外显示的功能，被private修饰的方法不会显示出来。帮助文档只会提取public protection修饰的功能。




小知识点：
    一个类中默认会有一个空参数的构造函数，这个构造函数的权限和所属类一致。如果该类被public修饰，那么默认的构造函数也是public的，如果该类不是public修饰，那么默认的构造函数也不是。默认构造函数的权限是随着类的变化而变化。




静态代码块


格式：
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("Hello World!");
}
Static 
{
System.out.println("C");
}

} Java StaticCodeDemo 运行结果：B  C  A  Hello World!