封装、构造方法、private、Static与this关键字、main（）_Day07

1：成员变量和局部变量的区别(理解)

　　 (1)定义位置区别：

　　　　     成员变量：定义在类中，方法外。

　　　　   局部变量：定义在方法中，或者方法声明上。

　　   (2)初始化值的区别：

　　　　  成员变量：都有默认初始化值。

　　　　 局部变量：没有默认初始化值。要想使用，必须先赋值。

　　 (3)存储位置区别：

　　　　 成员变量：存储在堆中。

　　　　 局部变量：存储在栈中。

　　(4)生命周期区别：

　　　　  成员变量：随着对象的创建而存在。随着对象的消失而消失。

　　　　局部变量：随着方法的调用而存在，随着方法调用完毕而消失。更严谨地说当局部变量的作用域结束时，即被销毁。

　　（5）就近原则：局部变量有，就用局部变量，局部变量没有，就找成员变量。如果成员变量也没有就报错

　　（6）成员变量与局部变量的区别：有所属关系，使用成员变量，否则使用局部变量，详细见下面的例子：

  /*

    成员变量与局部变量的使用区别，有所属关系，使用成员变量，否则使用局部变量

*/

class Demo3

{

    public static void main(String[] args)

    {

       GetSumTool gst = new GetSumTool();

       System.out.println(gst.getSum(2,3));

       Rec rec = new Rec();

       rec.height = 10;

       rec.width = 20;

       System.out.println("周长为："+rec.getZhouChang());

       System.out.println("面积为："+rec.getMianJi());

    }

}

//求两个数的和的工具,第二种好，因为a与b不是这个工具必须有的属性！没有所属关系！

class GetSumTool

{

    //方式一

    //int a;

    //int b;

    //public int getSum(){

    //  return a+b;

    //}

    //方式二

    public int getSum(int a,int b) {

       return a+b;

    }

}

//定义长方形类，求周长与面积

class Rec

{

    //方式一

    int height;

    int width;

    public int getZhouChang(){

       return 2*(height+width);

    }

    public int getMianJi(){

       return height*width;

    }

    //方式二

    //public int getZhouChang(int height,int width){

    //  return 2*(height+width);

    //}

    //public int getMianJi(int height,int width){

    //  return height*width;

    //}

}

2、匿名对象

　　 (1)匿名对象是对象的简化形式，即没有名字直接创建的对象。

　　　　 Person p=new Person; //有名字的对象，对象为p

　　　　  new Person();        //没有名字的对象

　　 (2)匿名对象的使用：

　　　　 对象方法只调用一次时。

　　　　作为实际参数传递时。

　　　　作为返回值返回时。

3：封装(理解)

　　　　 (1)隐藏实现的细节，提供公共的访问方式。 类，方法等其实都是封装的具体体现。

　　　　(2)private关键字

　　　　　　 A:用于修饰成员变量和成员方法。

　　　　　　B:被修饰的内容在其他类中是不可以被访问的。

　　　　 (3)常见的应用：(掌握)

　　　　　　 类中的所有成员变量私有，给出对应的get/set方法。其他的方法用Public修饰。代码体现：

  class Student

       {

           private String name;

           private int age;

           public Student(){}

           public Student(String name,int age)

           {

              this.name = name;

              this.age = age;

           }

           public void setName(String name)

           {

              this.name = name;

           }

           public String getName()

           {

              return name;

           }

           public void setAge(int age)

           {

              this.age = age;

           }

           public int getAge()

           {

              return age;

           }

       }

　　　　（4）定义一个封装类的步骤：

　　　　   a. 私有成员属性

　　　　   b. 至少一个空参的构造方法

　　　　  c. 普通方法

　　　　  d. 公共的get/set方法通常手动放在最后

　　（5）创建对象使用对象的步骤：

　　　　 a. 定义引用类型变量用来引用对象

　　　　  b.使用new关键字与构造方法完成对象创建

　　　　  c. 在构造方法的同时对成员变量赋值

　　　　 d. 使用get/set方法操作成员变量

　　　　 e. 使用对象名.方法名(参数)调用对象函数

　　（6）创建对象时JVM所作动作：

　　　　  A:栈内存开辟空间存储引用变量

　　　　 B:使用new创建内存空间

　　　　 C:调用构造方法

　　　　 D:成员变量默认初始化

　　　　 E:成员变量显示初始化

　　　　 F:构造函数初始化

　　　　H:对象创建结束，将地址赋值给引用变量

具体过程：对象内存图

　　（7）为成员变量赋值的方式：

　　　　 A:使用构造方法

　　　　 B:使用set方法

　　注意:

　　　　  构造方法与set方法均能为成员变量赋值，并不冲突。

　　　　   构造方法只在创建对象时进行成员变量初始化。

　　　　 对象创建后由set方法依据需求修改成员变量值。

4：构造方法(掌握)

　　  定义： 用来创建实例对象时调用的方法。

　　 作用之一：  创建同时可以给属性赋值

　　(1)格式及特点

　　　　  格式：

　　　　访问权限修饰符 类名(参数...){}

　　　　访问权限修饰符:

　　　　　　 public,private，一般用public

　　　　   特点：

　　　　  A:方法名和类名相同

　　　　 B:没有返回值类型

　　　　C:没有具体的返回值

　　(2)注意事项：

　　　　A:如果你不给构造方法，jvm会自动给你一个无参构造方法。多个构造方法使用重载的方式给出。

　　　　 B:如果你给出了构造方法，那么，jvm将不再提供无参构造方法。

　　　　这个时候，你如果要使用无参构造方法：只能自己提供

　　　  推荐：永远手动给出无参构造方法。

5：this关键字(掌握)

　　(1)是一个关键字。代表当前对象的引用。

　　　　//简单记：在方法中，哪个对象调用方法，this就代表谁。

　　  (2)应用场景：

　　　　 a.解决局部变量隐藏成员变量问题,this关键字调用成员变量。

　 例子：

 class Person(){

            private name;   //成员变量

            public void eat(String name){  //局部变量

            this.name=name;

            }

       }

       b.在构造方法中调用其他的构造方法(必须写在第一行)  this();

       例子：

           //定义了一个空参的构造方法

    public Person(){

       System.out.println("我是空参的构造方法！");

    }

    //定义了一个有参的构造方法

    public Person(String name){

       this.name = name;

       System.out.println("我是有一个参数的构造方法！");

    }

    //定义了两个参数的构造方法

    public Person(String name,int age) {

       this(name);     //必须放在第一行

       //this.name = name;

       this.age = age;

       System.out.println("我是有两个参数的构造方法！");

    }

       c.在其他方法中可以使用this.普通方法名()调用普通方法

       public void showMe(){

           System.out.println("name:"+this.getName()+" age:"+this.getAge());

    }

6：static关键字(理解)

　　 (1)是一个关键字。可以修饰成员变量和成员方法。

　　 (2)静态的特点：

　　　　   A:随着类的加载而加载

　　　　  B:优先于对象存在

　　　　C:被类的所有对象共享

　　　　 D:可以通过类名调用

　　 (3)静态的注意事项：

　　　　  A:在静态方法中是没有this关键字的。因为this关键字是对象的引用，随对象的创建而生，而静态方法随着类的加载而加载，早于对象的创建。

　　　　 B:静态方法只能访问静态的成员变量和静态的成员方法。因为非静态的可能还没有创建。

　　 (4)静态内容的调用：

　　　　 A:被对象调用

　　　　 B:被类名调用

　　　　 推荐被类名调用。

　　 (5)什么时候该用static呢?

　　　　如果某个内容是所有对象共享的，就用静态修饰。

　  （6）静态关键字的内存图：

(7)静态方法覆盖:静态方法只能覆盖静态方法，静态方法只能被静态方法覆盖。

/*
    静态方法覆盖:
        静态方法只能覆盖静态方法，静态方法只能被静态方法覆盖。
*/
class Demo3
{
    public static void main(String[] args)
    {
        Person p = new Person();
        p.method();
        Student s = new Student();
        s.method();
    }
}

class Person
{
    /*
    public void method(){
        System.out.println("父类非静态方法");
    }
    */
    public static void method(){
        System.out.println("父类静态方法");
    }
}

class Student extends Person
{
    /*
    public void method(){
        System.out.println("子类非静态方法");
    }
    */
    public static void method(){
        //super.method();
        System.out.println("子类静态方法");
    }

}

8：主函数main（）

　　主函数是静态的   public static void main（String[] args）{}

　　   A.static为固定修饰，与对象无关是JVM的入口

　　  B.public公共访问权限允许外界调用

　　  C.无返回值，定义返回值类型没有意义

　　  D.参数为String数组类型，用来接收字符串参数

　　  E.函数名main()为JVM固定查找的字符串不能修改

　　   F.形参名可以修改并使用