java基础--笔记6



面向过程：

               面对的是具体的实现特定功能和具体代码。每一个功能我们都要参与。所有的事情都是自己独立的在做。

               代表语言：C语言。

               瓶颈问题：面对大的需求，大型的企业开发，如果函数书写的特别多时，整个项目维护起来十分困难。

面向对象：

               面向对象是基于面向过程的。面向对象的底层，就是封装了面向过程的那些具体实现步骤。

               在开发中中，遇到需求时，我们就要封装了具体功能的那个对象，找到这个对象，调用其中特定的方法，就可以完成相应的操作。这时调用者不再关心具体功能如何实现，我们只要知道哪一个对象，哪一个方法能完成什么功能即可。

面向对象的好处：    

                  1，让我们从具体的参与者，变成指挥者。

                  2，面向对象的思维模式更符合人们的日常生活习惯。

把对象用代码来体现的话，需要注意：

          对象所具有的特点，就是类中所写的属性。属性是直接定义在类中的成员变量。

          对象所具备的动作。就是类中的所写的具体功能（方法）。

          当我们把事物描述完成，通过new关键字就可以创建这个类所对应的具体的实例（实体，个体）。把这个个体，实例，实体叫做对象。

函数定义格式：

修饰符 返回值类型 函数名（参数列表）

{ 

     函数体

}

类是现实生活中事物的抽象描述，它就是一个模板。

对象是基于类（模板）创建出来的一个具体实体。

对象的内存加载过程：

     在DOS命令行中输入java PersonDemo回车之后，这时启动JVM，然后JVM会加载PersonDemo这个class文件。运行这个class文件中的main方法，在运行main方法时执行到new Person();这时JVM又会加载Person.class这个文件。然后开始在堆中创建Person对象。在创建Person对象的时候，Person类中的所有成员变量，都会随着对象的创建而出现在堆中。并且这些成员变量都有默认的初始化值。当对象创建完成之后，把这个堆中的对象的内存地址赋给main方法中的p这个引用变量。

//描述一个人
class Person
{
     int age;  //人的年龄属性
     String name;  //人的姓名属性
     void speak()  //人的说话行为
     {
          int age = 10; 
          System.out.println("speak:age="+age+",name="+name);
     }
}
class  PersonDemo
{
     public static void main(String[] args)
     {
         
          //基于Person.class文件创建出了一个Person的实体对象
          Person p = new Person();
          p.age = 21;
          p.speak；

     }
}

成员变量和局部变量的区别：
     1、在代码中的位置不同
          成员变量书写在类的成员位置上。局部变量书写方法中，或者在有效的范围(局部)。
     2、他们的初始化时间不一样
          成员变量会随着对象的创建而在堆中出现，并且他们有默认的初始化值。
          局部变量他存在方法中，必须手动给其赋值。
     3、他们在内存中的位置不同
          局部变量会随着方法的压栈，而在栈内存中出现。
          成员变量会随着对象的创建而在堆内存中出现。
     4、他们的生命周期不同
          局部变量会在方法压栈时出现，而在方法弹栈时消失。即在这个方法的运行周期内是有效的。
          成员变量会在对象创建时在堆中出现，会随着对象的消失，而消失。可以直接参与运算。

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

                              2，可以将匿名对象作为实际参数进行传递。

格式： new Person（）.sperk（）；

匿名对象，一旦使用结束，这个对象就变成垃圾，等垃圾回收器把它收回。

封装  ：封装不是私有。

使用方法来封装具有独立功能的那段代码。方法就是一个封装体。

方法存放在类，类就是封装了方法，以及其他成员，说明类也是一个封装体。

封装隐藏了具体实现细节。需要对外暴露使用的规则，使用方法。

封装的好处：

     1，隐藏实现细节，对外提供相应的访问方式 

     2，封装提高了代码的复用性

     3，private关键字只是封装的一种体现。如果类的成员变量被私有之后，必须对外提供相应的set或get方法。要求以后开发中，所有的成员必须私有，同时对外提供相应的set或get方法

private：私有

     1，权限修饰符，用于修饰类中的成员（成员变量，成员函数）

     2，私有后只能在本类使用，在类以外的其他程序无法访问。私有仅是封装的一种表现形式。

     3，当成员变量被私有后，需要对外提供相应访问成员变量的方法。这类方法一般命名为getXxx或者setXxx

之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断等语句，对访问的数据进行操作，提高代码的健壮性。

构造函数：1，函数名与类名相同

                2，不用定义返回值类型

                3，不可以写return语句

Person（int a ， String num）

{

     System.out.println("a="+a+",num="+num);

}

构造函数可以私有化。

对象一建立就调用对应的构造函数。

构造函数的作用：可以用于给对象进行初始化。

构造函数的小细节：当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。当在类中自定义了构造函数后，默认的构造函数就没有了。

当提供了相应的初始化的构造函数之后，程序还有必要提供相应的set或者get方法吗？

构造函数是用于给对象创建额时候初始化的。一旦对象创建完成之后，这个初始化动作就执行完成。

这个时候还要修改成员变量的属性的话，只能通过set方法完成，不能通过重新创建对象这种方式（错误）。

构造函数和一般函数的区别：
     1，调用的时间不同
          构造函数是在对象创建时自动调用
          一般函数是在对象创建完成之后，使用对象来调用。
     2，他们的作用不同
          构造函数的作用：就是给对象初始化用的。
          一般函数的作用：完成某一个功能的。
     3，他们能相互调用吗？
          一般函数不能调用构造函数，为什么？
          一般函数是被对象调用的。那就说明在这个一般函数执行的时候，对象已经存在。而构造函数是创建对象时调用。
     构造函数可以调用一般函数吗？可以
             在执行构造函数的时候，堆中已经把这个对象创建好了，只不过这个对象中的所有数据都是默认的初始化值。此时对象的初始化动作还没有彻底执行结束。等构造函数中所有的代码全部执行完成之后，这时真个对象的初始化全部结束。

构造函数的作用：它是专门用来给对象进行初始化的。在创建对象的时候，可以通过构造函数给对象进行成员变量显示初始化。

构造函数什么时候执行

     在对象在堆中创建完成之后，其中的所有成员变量都默认初始化结束之后，自动的调用与之对应的构造函数。

     注意：一旦对象创建完成之后，构造函数就执行结束了。它使命就完成。我们不能在通过对象去调用任何的构造函数。

什么时候定义构造函数：

当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。当有未知内容参与运算时，需要定义参数。

无参数的构造函数（默认构造函数）：Person（）{}

注意：在开发时。如果我们显示指定的构造函数，这时JVM就不会再给我们的程序添加那个默认的构造函数了。

在开发时，到底要不要写无参数的构造函数？

如果在程序中，创建对象时，所有的对象都需要在创建的时候就明确具体的初始化数据。这时就不用在类中写相应的无参数构造函数。

如果程序没有了无参数的构造函数之后，创建对象时，必须给每一个对象显示指定参数。

在一个类中，如果有多个构造函数，他们是以重载的形式出现。

this ： 关键字，用于区分局部变量和成员变量同名情况。

this的特点：就代表本类的对象，代表所在函数所属对象的引用。既那个对象在调用this所在的函数，this就代表那个对象。

this（实际参数）；this访问的是成员变量。

this的应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。但凡本类功能内部使用了本类对象，都用this表示。

this语句用于构造函数之间进行互相调用。

通过函数名，调用的是一般函数。

this语句只能定义在构造函数的第一行。因为对象初始化的动作要先执行。

this不能用在static修饰的方法里和static修饰的代码块里。

练习：

需求：在Person类中定义功能，判断两个人是否是同龄人。

思路：1，需要一个类，类名为Person

          2，类中还需要一个功能

               类中的功能是通过函数体现的，需要写函数

          3，这个功能是用来比较两个人的年龄，说明这个功能比较完之后会得到一个boolean值

               定义功能：     

                              1，明确参数列表：调用这个方法的对象，本身就要参与到比较中，那么调用这个方法的对象的年龄可以通过this取到。这时还需要另外一个人的年龄。这时只需要将这个人对象传递进来，这时我们就可以通过这个人对象，得到他的年龄。

                              2，明确返回值类型：boolean

          4，功能的方法签名书写如下：

               boolean comparePersonAge（ Person p）

               {

               }

          5，还需要年龄属性

static  关键字 静态

用法：是一个修饰符，用于修饰成员（成员变量，成员函数）

静态修饰内容，被内存共享。

当成员被静态修饰后，就多了一种调用方式，除了可以被对象调用外，还可以直接被类名调用。  类名.静态成员。

定义时，特有数据要随着对象存储。

被静态修饰的成员，称为类的成员。

方法区，共享区，数据区。

static特点：

     1，随着类的加载而加载，也就是说，静态会随着类的消失而消失，说明它的生命周期最长。

     2，优先与对象存在。明确一点，静态是先存在的，对象是后存在的。

     3，被所有对象所共享

     4，可以直接被类名调用

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

1，存放位置。

     静态变量随着类的加载而存在与方法区中。

     实例变量随着对象的建立而存在与堆内存中。

2，生命周期

     类变量生命周期最长，随着类的消失而消失。

     实例变量生命周期随着对象的消失而消失。

     

静态的使用注意事项：

1，静态方法只能访问静态成员，非静态方法既可以访问静态也可以访问非静态。

2，静态方法不可以定义this，super关键字

     因为静态优先与对象存在，所以静态方法中不可以出现this

3，主函数是静态的。

静态有利有弊

利：对对象的共享数据进行单独空间存储，节省空间，没有必要每一个对象中都存储一份。

     可以直接被类名调用。

弊：生命周期过长。访问出现局限性（静态虽好，只能访问静态）

为什么静态无法访问非静态?

     被静态修饰的方法，属于类的方法，它会随着类的加载一起加载到内存中。可以通过类名直接去访问，此时在内存中还没有对象。

在被静态修饰的方法中，无法使用关键字this，super