面向对象

面向对象是一种思想，可以将复杂问题简单化，从执行者变为执行者，例子老板调用员工，会洗衣服的对象，服务员点菜
类与对象
1、类和对象的关系。
类就是：对现实生活中事物的描述。
对象：就是这类事物，实实在在存在个体。

现实生活中的对象：张三 李四。
想要描述：提取对象中共性内容。对具体的抽象。
描述时：这些对象的共性有：姓名，年龄，性别，学习java功能。
映射到java中，描述就是class定义的类。
具体对象就是对应java在堆内存中用new建立实体。
汽车厂
类是图纸，对象是车
定义类，就是在描述事物，就是在定义属性和行为。属性和行为共同成为类中的成员(成员变量和成员方法)。

Car c = new Car();c就是一个类类型变量。记住：类类型变量指向对象。
多个引用指向同一对象的理解
2、成员变量和局部变量。
作用范围。
成员变量作用于整个类中。
局部变量变量作用于函数中，或者语句（for等）中。
在内存中的位置：
成员变量：在堆内存中，因为对象的存在，才在内存中存在。
局部变量：存在栈内存中。
3、匿名对象
匿名对象使用方式一：当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化。
如果对一个对象进行多个成员调用，必须给这个对象起个名
字。
匿名对象使用方式二：可以将匿名对象作为实际参数进行传递。

    Car q = new Car();        show(q);        //q=null；        //show(new Car());new对象变成垃圾的时间不一样，在show执行完就为垃圾，上面的在main执行完就变成垃圾    }    //需求：汽车修配厂。对汽车进行改装，将来的车够改成黑车，三个轮胎。    public static void show(Car c)    {        c.num = 3;        c.color = "black";        c.run();    }

4、封装
是指隐藏对象的属性和和实现细节，仅仅对外提供公开访问方式
优点：便于使用，将变化隔离，重用性，安全性
使用：将不需要对外提供的隐藏起来，把属性隐藏起来，提供对外访问方式

/*private :私有，权限修饰符：用于修饰类中的成员(成员变量，成员函数)。私有只在本类中有效。将age私有化以后，类以外即使建立了对象也不能直接访问。但是人应该有年龄，就需要在Person类中提供对应访问age的方式。注意：私有仅仅是封装的一种表现形式。之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断等语句。对访问的数据进行操作。提高代码健壮性。*/class Person{    private int age;    public void setAge(int a)    {        if(a>0 && a<130)        {            age = a;            speak();        }        else            System.out.println("feifa age");    }    public int getAge()    {        return age;    }    private void speak()    {        System.out.println("age="+age);    }}class PersonDemo{    public static void  main(String[] args)    {        Person p = new Person();        //p.age = -20;        p.setAge(-40);        //p.speak();    }}

5、构造函数
函数名与类名相同
不用定义返回值类型
不可以写return
给对象初始化

package B05;/*1、对象一建立就会调用与之对应的构造函数。。构造函数的小细节：当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。当在类中自定义了构造函数后，默认的构造函数就没有了。================================================2、构造函数和一般函数在写法上有不同。在运行上也有不同。构造函数是在对象一建立就运行。给对象初始化。而一般方法是对象调用才执行，给是对象添加对象具备的功能。一个对象建立，构造函数只运行一次。而一般方法可以被该对象调用多次。3、什么时候定义构造函数呢？当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。*/class Person{    private String name;    private int age;    /*    构造代码块。    作用：给对象进行初始化。    //对象一建立就运行，而且优先于构造函数执行。    和构造函数的区别：    构造代码块是给所有对象进行**统一初始化**，    而构造函数是给对应的对象初始化。    构造代码快中定义的是不同对象共性的初始化内容。    */    {        //System.out.println("person code run");        cry();    }    Person()    {        System.out.println("A: name="+name+",,age="+age);    }    /**/    Person(String n)    {        name = n;        System.out.println("B: name="+name+",,age="+age);        //cry();    }    /*    public void setName(String n)    {        name  = n;    }    public String getName()    {        return name;    }    */    Person(String n,int a)    {        name = n;        age = a;        System.out.println("C: name="+name+",,age="+age);        //cry();    }    public void cry()    {        System.out.println("cry......");    }}class  PersonDemo2{    public static void main(String[] args)     {        Person p1 = new Person();        Person p2 = new Person("lisi");        //System.out.println(p2.getName());        //Person p3 = new Person("wnagu",10);    }}

6、this关键字

Person(String name)    {        name  = name;    }    //不可以，局部中有name，就在局部中找，没有才在成员中找    Person(String n)    {        name  = n;    }    //相同效果    Person(String name)    {        this.name = name;    }//==================================public void speak()    {        System.out.println("name="+this.name+"...age="+this.age);        this.show();//写不写this都行    }/**this:看上去，是用于区分局部变量和成员变量同名情况。this：就代表本类的对象，到底代表哪一个呢？    this代表它所在函数所属对象的引用。    简单说：哪个对象在调用this所在的函数，this就代表哪个对象。this的应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。        但凡本类功能内部使用了了本类对象，都用this表示。*//*应用：    需求：给人定义一个用于比较年龄是否相同的功能。也就是是否是同龄人。    */    public boolean compare(Person p)    {        return this.age==p.age;    }    //----------------------        public static void main(String[] args)     {        Person p1 = new Person(20);        Person p2 = new Person(25);        boolean b = p1.compare(p2);        System.out.println(b);/*this语句 :用于构造函数之间进行互相调用。this语句只能定义在构造函数的第一行。因为初始化要先执行。*/Person(String name)    {        //this();        this.name =name;    }    Person(String name,int age)    {        this(name);        this.age = age;     }

7、static关键字

/**静态：static。相同数据时用用法：是一个修饰符，用于修饰成员(成员变量，成员函数).当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用。类名.静态成员。static特点：1，随着类的加载而加载。   也就说：静态会随着类的消失而消失。说明它的生命周期最长。2，优先于的对象存在明确一点：静态是先存在。对象是后存在的。3，被所有对象所共享4，可以直接被类名所调用。实例变量和类变量的区别：1，存放位置。    类变量随着类的加载而存在于方法区中。    实例变量随着对象的建立而存在于堆内存中。2，生命周期：    类变量生命周期最长，随着类的消失而消失。    实例变量生命周期随着对象的消失而消失。静态使用注意事项：1，静态方法只能访问静态成员。    非静态方法既可以访问静态也可以访问非静态。2，静态方法中不可以定义this，super关键字。    因为静态优先于对象存在。所以静态方法中不可以出现this。3，主函数是静态的。静态有利有弊利处：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。    可以直接被类名调用。弊端：生命周期过长。      访问出现局限性。(静态虽好，只能访问静态。)*/class Person{    String name;//成员变量，实例变量。    static String country = "CN";//静态的成员变量，类变量。

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

什么时候使用静态
什么使用静态？

要从两方面下手：
因为静态修饰的内容有成员变量和函数。
1、什么时候定义静态变量(类变量)呢？
当对象中出现共享数据时，该数据被静态所修饰。
对象中的特有数据要定义成非静态存在于堆内存中。

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

class Person{    String name;    static String country = "cn";    public  static void show()    {        System.out.println(contry+"haha");//没用到非静态    }  }class  {    public static void main(String[] args)     {        Person p = new Person();        p.show();        //Person .show();可以不用new一个对象    }}