java面向对象（一）

面向对象思想概述

     面向对象时基于面向过程的编程思想。

         面向过程：强调的是每一个功能的步骤。

          面向对象：强调的是对象，然后由对象去调用功能。

     面向对象思想特点：

             是一种更符合我们思想习惯的思想。

             可以将复杂的事情简单化

             将我们从执行者变成指挥者。

   面向对象开发，设计，特征

          就是不断的创建对象，使用对象，指挥对象做事情。

   面向对象设计

           其实就是在管理和维护对象之间的关系。

  面向对象的特征

           封装（encapsulation）

           继承（inheritance）

           多态（polymorphism）

类与对象：

   类：                                    事物：

        变量                                     属性

        方法                                     行为

        属性：该事物的描述信息。

       行为：该事物能够做什么。      

     类：是一组相关的属性和行为的集合，是一个抽象的概念。

     对象 ：是该类事物的具体表现形式，具体存在的个体。 

      举例说明：

            抽象手机类

          如何创建对象:

                  类名   对象名=new  类名（）;

           如何调用对象中的属性和方法：

                   对象名.变量名;

                  对象名.方法名（参数，参数....）;

       代码：

  class OOP_demo01

{

    public static void main(String [] args)

{

      phone iphone5s=new phone();

      iphone5s.Call("miss gao");

      iphone5s.SendMassage("miss gao");

      iphone5s.PlayGame();

  

}

}

class phone{

  //品牌

    String brand;

  //颜色

    String color;

  //价格

     int price;

   //打电话

   public void Call(String name)

   {

        System.out.println("给"+name+"打电话！");

   }   

   

   //发短信

   public void SendMassage(String name)

     {

     System.out.println("给"+name+"发短信！");

}

   //玩游戏

    public void PlayGame()

    {

   System.out.println("玩游戏！");

}

}  

成员变量和局部变量的区别？

     A：在类中的位置不同

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

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

    B:在内存中的位置不同

         成员变量：在堆内存中

         局部变量：在栈内存中

    C:生命周期不同

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

          局部变量：随着方法的调用而存在，随着方法的调用完毕而消失。

      D:初始值不同

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

            局部变量：没有默认初始值。必须定义赋值，才能被使用。

    

   匿名对象：就是没有名字的对象； 

   匿名对象应用的场景： 

        1.调用方法：仅仅只调用一次的时候。

         注意：调用多次的时候，不适合。

        调用匿名对象的好处是： 匿名对象调用完毕就会被垃圾回收器回收。

       2.匿名对象可以作为实际参数传递。

  代码讲解： 

 class  demo{

   public void show()

   {

      System.out.println("温馨提示！");

   }

}

class NoName{

   public static void main(String[] args)

   {

//调用demo类的时候可以不用创建demo类的实例  直接调用类中的方法  该过程称为 匿名对象 调用！

       new demo().show();

   }

}

封装：是指隐藏对象的属性和实现的细节（方法），仅对外提供公共访问方式。

封装的好处：

                    1.隐藏实现细节，提供公共的访问方式。

                    2.提高了代码的复用性。

                    3.提高了安全性。 

封装的原则：

                  将不需要对外提供的内容都隐藏起来

                  把属性隐藏，提供公共的方法对其访问。

private关键字 

                是一个权限修饰符

               可以修饰成员（成员变量和成员方法）

                被private修饰的成员只能在本类中才能访问。

private最常见的应用：  

            把所有的成员变量用private修饰

            提供对应的getxxx()和setxxx()方法

       代码举例：  

  class  PackageDemo{

     public static void main(String [] aegs)

{

    student s=new student();

s.setName("李白");

s.setAge(30);

System.out.println("--------------");

System.out.println(s.getName());

System.out.println(s.getAge());

}

}

class student{

   private String Name;

   private int Age;

//this 指当前对象 student类

   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 this.Age; 

   }

}

构造方法：

           给对象的数据进行初始化。

 构造方法格式：

           方法名与类名相同

           没有返回值类型，连void都没有。

          没有具体的返回值。

static关键字：

      针对有多个对象有共同的成员变量值的时候（java提供了一个关键字：static）来修饰！

static的特点：（它可以修饰成员变量，同时也可以来修饰成员方法）

                   1.随着类的加载而加载

                   2.优先于对象存在。

                   3.被类的所有对象共享。

                   4.可以通过类名来调用（重点）

                           其实也可以通过对象名来调用

                    static（静态修饰）的内容一般我们称为：与类相关的，类成员。

static关键字的注意事项：

               1.   在静态方法中是没有this关键字的

               2.静态方法只能访问静态的成员变量和静态的成员方法。  

                            静态方法：

                                          成员变量：可能访问静态变量

                        非静态方法：     

                                        成员变量：可以是静态的，同时也可以是非静态的变量。

 体现代码：

   class person{
   String name;
   int age;
  // String country;
  //采用static来修饰时：成员变量的属性针对多个对象使用。
  static String country;
   public person()
   {
  
   }
   public person(String Name,int Age)
   {
      this.name=Name;
   this.age=Age;
   }
   public person(String Name,int Age,String Country)
   {
      this.name=Name;
   this.age=Age;
   this.country=Country;
   }
  
   public void show()
   {
       System.out.println("姓名："+this.name+",年龄："+this.age+",国籍："+this.country);
   }
}

class  staticDemo{
   public static void main(String[] args)
   {
       person p1=new person("张杰",20,"中国");
    p1.show();
   
   
 //   person p2=new person("周杰伦",25,"中国");
  //  p2.show();
   
 //   person p3=new person("李连杰",30,"中国");
  //  p3.show();
    System.out.println("--------------------");
    person p2=new person("周杰伦",25);
    p2.show();
    person p3=new person("李连杰",30);
    p3.show();
   }
}

打印结果：

   姓名：张杰,年龄：20,国籍：中国
 --------------------
 姓名：周杰伦,年龄：25,国籍：中国
 姓名：李连杰,年龄：30,国籍：中国

 静态变量和成员变量的区别：

             A：所属不同

                   静态变量属于类，所以也称为类变量

                   成员变量属于对象，所以也称为实例变量（对象变量）

            B：内存中的位置不同

                  静态变量存储于方法的静态区。

                 成员变量存储于堆内存

            C：内存出现的时间不同

                 静态变量随着类的加载而加载，随着类的消失而消失。

                 成员变量随着对象的创建而存在，随着对象的消失而消失。
            D:调用不同

                静态变量可以通过类名调用，也可以通过对象调用

               成员变量只能通过对象来调用。