JAVA 面向对象 一

面向对象

面向对象是一种思想，将事情简单化，由执行者转化为指挥者

特征：封装，继承，多态

类和对象的关系

类就是对现实生活中事物的描述

对象是这类事物中实实在在存在的个体

想要描述：提取对象中共性内容。对具体的抽象。 映射到Java中描述就是class定义的类。

描述事物就是在描述事物的属性和行为，属性和行为共同成为类中的成员。

创建对象就是在堆内存中产生一个实体。

成员变量和局部变量

成员变量作用于整个类中，局部变量作用于函数中或语句中。

成员变量存在于堆内存中，因为对象的存在才在内存中存在，局部变量在栈内存中

成员变量随着对象的创建而存在，随着对象的消失而消失，局部变量随着所属区域的执行而存在，随着所属区域的结束而释放。
成员变量都有默认初始化值， 局部变量没有默认初始化值。

函数

函数就是定义在类中的具有特定功能的小程序，也称为方法

函数的格式

修饰符 返回值类型 函数名（参数类型，形式参数）{

函数体；

}
主函数
public ：代表该访问权限是最大的
static：代表主函数随着类的加载已经存
void：主函数没有具体的返回值
main：不是关键字，但是是一个特殊发单词，可以被jvm识别
String[ ] args ：函数的参数，参数类型是一个数组，该数组的元素是一个字符串，居jvm在调用时传入的是new String[0]

如何定义一个函数

（1）先明确该功能的运算结果（明确返回值类型）

（2）再明确在定义该功能的过程中，是否需要未知的内容参与运算（明确该参数类型和个数）

重载：方法名相同，但参数个数及顺序，数据类型不同

什么时候用重载

当定义的功能相同，但参与运算的未知内容不同，那么这时就定义一个函数名称以表示其功能，方便阅读，而通过参数列表的不同来区分多个同名参数，重载和返回值类型没有关系。

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

当一个类中没有定义构造函数时，系统会，默认先给该类加入一个空参的构造函数

当在类中定义了构造函数后，默认的构造函数就没有了。

构造函数特点
函数名与类名相同
不用定义返回值类型
没有具体的返回值。

构造函数和一般函数的区别

构造函数在对象已建立就运行，给对象初始化。一般方法是对象调用才执行，给对象添加具备的功能。

一个对象建立，构造函数只执行一次。而一般方法可以被对象调用多次

当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。

构造代码块：给所有的对象就行初始化{}

对象已建立就运行，优先于构造函数执行，构造代码块定义的是不同对象的共性内容。

权限修饰符

权限由大到小

public--->protected--->friendly--->private

public可以修饰类，数据成员，构造方法，方法成员。被public修饰的成员，可以在任何一个类中被调用，不管同包或不同包，是权限最大的一个修饰符

protected可以修饰数据成员，构造方法，方法成员，不能修饰类（此处指外部类，不考虑内部类）。被protected修饰的成员，能在定义它们的类中，同包的类中被调用。如果有不同包的类想调用它们，那么这个类必须是定义它们的类的子类

friendly可以修饰类，数据成员，构造方法，方法成员，都能够使用默认权限，即不写任何关键字。默认权限即同包权限，同包权限的元素只能在定义它们的类中，以及同包的类中被调用。非同包中继承也不行

private可以修饰数据成员，构造方法，方法成员，不能修饰类（此处指外部类，不考虑内部类）。被private修饰的成员，只能在定义它们的类中使用，在其他类中不能调用

常见规则如下：

所有的类都用public修饰。并且，在一个java文件中，只写一个类。
所有的成员变量用private修饰。
所有的成员方法用public修饰。
如果是抽象类或者接口：public abstract + …
所有的构造方法用public修饰。
如果类是工具类或者单例类：构造用private修饰

创建对象

     /*    类和对象的关系    现实生活中的对象：张三，王五    想要描述：提取对象中共性内容，对具体的抽象，描述时，这些对象的共性是（姓名，年龄，性别）    映射到java中，描述就是class定义的类。      具体对象就是对应java在堆内存中用new建立实体。       类就是：对现实生活中事物的描述。      对象：就是这类事物，实实在在存在个体。            */            //需求：描述汽车(颜色，轮胎数)。描述事物其实就是在描述事物的属性和行为。            //属性对应是类中变量，行为对应的类中的函数(方法)。      //其实定义类，就是在描述事物，就是在定义属性和行为。属性和行为共同成为类中的成员(成员变量和成员方法)。                class Car      {          //描述颜色          String color = "红色";          //描述轮胎数          int num = 4;                //运行行为。          void run()          {                    System.out.println(color+".."+num);          }                }                  class  CarDemo      {          public static void main(String[] args)           {              //生产汽车。在java中通过new操作符来完成。              //其实就是在堆内存产生一个实体。              //Car c = new Car();//c就是一个类类型变量。记住：类类型变量指向对象。                    //需求：将已有车的颜色改成蓝色。指挥该对象做使用。在java指挥方式是：对象.对象成员              //c.color = "blue";                            //c.run();                    //Car c1 = new Car();              //c1.run();//red 4;                  //      Car c = new Car();      //      c.num = 5;              /*             new Car().num = 5;             new Car().color = "blue";             new Car().run();                  Car c = new Car();             c.run();             c.num = 4;             new Car().run();             */              //匿名对象使用方式一：当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化。              //如果对一个对象进行多个成员调用，必须给这个对象起个名字。              //匿名对象使用方式二：可以将匿名对象作为实际参数进行传递。                          Car q = new Car();              show(q);                    //show(new Car());          }                //需求：汽车修配厂。对汽车进行改装，将来的车够改成黑车，三个轮胎。          public static void show(Car c)          {              c.num = 3;              c.color = "black";              c.run();          }      }  

封装
封装：是指隐藏对象的属性和实现细节，仅对外提供公共的访问方式。
优点：
*将变化隔离
*便于使用
*提高重用性
*提高安全性
封装原则：
*将不需要对外提供的内容都隐藏起来
*把属性都隐藏，提供公共方法对其访问。
private（私有）关键字
*是一个权限修饰符。
*用于修饰成员（成员变量和成员函数）。
*被私有化的成员仅在本类中有效。
常用之一：将成员变量私有化，对外提供对应的set，get方法对其进行访问。提高数据访问的安全性。

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

this关键字的应用 及 在构造函数中的调用
this关键字特点：this代表其所在函数所属对象的引用。换言之-----this代表本类对象的引用。
什么时候用this关键字呢？
1.用于区分同名变量的情况（成员变量和局部变量同名的时候）
2.用于构造函数间的调用

总之当在函数内需要用到调用该函数的对象时，就用this

    /*     this:看上去，是用于区分局部变量和成员变量同名情况。     this为什么可以解决这个问题？     this到底代表的是什么呢？          this：就代表本类的对象，到底代表哪一个呢？         this代表它所在函数所属对象的引用。         简单说：哪个对象在调用this所在的函数，this就代表哪个对象。               this的应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。             但凡本类功能内部使用了了本类对象，都用this表示。          */            class Person      {          private String name;          private int age;          Person(int age)          {              this.age = age;          }          Person(String name)          {              this.name = name;          }          Person(String name,int age)          {              this.name = name;              this.age = age;          }                public void speak()          {              System.out.println("name="+this.name+"...age="+this.age);              this.show();          }          public void show()          {              System.out.println(this.name);          }                /*         需求：给人定义一个用于比较年龄是否相同的功能。也就是是否是同龄人。         */          public boolean compare(Person p)          {              return this.age==p.age;                }      }            class PersonDemo3       {          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);                          //Person p = new Person("lisi");              //Person p1 = new Person("zhangsan");              //p.speak();              //p1.speak();              //p.speak();          }      }  

    /*     this语句 :用于构造函数之间进行互相调用。          this语句只能定义在构造函数的第一行。因为初始化要先执行。     */            class Person      {          private String name;          private int age;                    {                            System.out.println("code run");          }                    Person()          {              //this("hah");              System.out.println("person run");          }          Person(String name)          {              //this();              this.name =name;          }          Person(String name,int age)          {              //this(name);              //this.name = name;              this.age = age;                        }            }            class  PersonDemo4      {          public static void main(String[] args)           {              new Person();              //Person p = new Person("lisi",30);              //Person p1 = new Person("lisi2",36);                }      }