封装、构造方法、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;

    //}

}
View Code

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;

           }

       }
View Code

    (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());

    }

 
View Code

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("子类静态方法");
    }
    
}
View Code

 8:主函数main()

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

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

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

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

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

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

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

原文地址:https://www.cnblogs.com/hezhiyao/p/7470476.html