面向对象

面向对象

　　我们都说java是面向对象的编程语言，那什么是面向对象呢？什么是类呢？什么是方法呢？

类、对象、方法

　　类是对象的抽象定义，对象是类的具体实例。

　　类：指的是一类东西，比如汽车，人类，书等这些都指的是一类东西或物品。

　　对象：指类的具体的实体，比如一辆汽车，一本书等，我们要记住一切皆对象（东西）。

　　同时对象具有状态（属性）和行为（方法）

　我以人为例：
　　人属性有：脸，手，脚，鼻子，耳朵，身高，性别，鼻子，耳朵等属性
　　人的行为（方法）：吃，喝，跑，睡觉等。

　这几个大家都能理解吧，而java中是如何创建类和对象的呢

　先创建一个学生类（这些都是学生的属性和方法）

public class Student {
    String name;    　　//姓名
    int age;           //年龄
    String classNo;    //班级
    String hobby；     //爱好

    public void chi(){
        System.out.println(name+"吃饭了")
    }

    //输出信息方法
    public void show(){
        System.out.println(name + "\n年龄：" + age + "\n就读于：" +classNo + "\n爱好：" + hobby);
    }
}

　　这样就创建好一个类了,那如何创建一个对象呢。

　　首先举一个例子：小李设计了一张汽车设计图，然后交给生产车间来生产汽车，有黑色的、红色的、白色的… 这里，汽车设计图就是我们说的类（class），生产车间就是new构造器（大部分对象都是new出来的），生产出来的汽车就是我们要说的对象。可以说java编程实质就是构建类的过程。

public class InitialStudent {
    public static void main(String args[]){
        Student student = new Student();    //建立对象
        student.name = "小明";        　　　　//给对象赋值
        student.age = 10;
        student.classNo = "S1班";　　　　　　
        student.hobby = "篮球";
        student.chi();
        student.show();　　　　　　　　　　　　//调用方法
    } 
}

　　到现在我都是以自己的组织的语言给大家讲解，为的是让大家能够理解，那么java编程的规范有哪些，它的具体的细节又有哪些下面我就具体讲一下

类的定义

　　类必须先定义才能使用。类是创建对象的模板,创建对象也叫类的实例化。（类是对象的抽象定义，对象是类的具体实例）类实质上是一个数据类型。

例子：

public class Dog
{
   String name;
   int age;

   void bark()//汪汪叫
   {
       System.out.println("汪汪，不要过来");
   }
   void hungry()
   {
       System.out.println("主人，我饿了");
   }
}

对示例的说明:

public 是类的修饰符，表明该类是公共类，可以被其他类访问。
- 一个类保存到一个文件中，并且文件名要与类名相同。（一个文件中可以运行多个类声明，只能有一个类是public,文件名必须和该类类名一致）
class 是定义类的关键字。
Dog是类的名称。
name,age是类的成员变量，也叫属性；bark(),hungry()是类中的函数，也叫方法。
对象实例化： 类名对象名 = new 类名(); //未实例化的对象不能访问其属性和方法
访问属性：对象名.属性名
访问方法：对象名.方法名(参数列表)

作用域修饰词

　　1、**public：**public表明该数据成员、成员函数是对所有用户开放的，所有用户都可以直接进行调用

　　2、**private：**private表示私有，私有的意思就是除了class自己之外，任何人都不可以直接使用，私有财产神圣不可侵犯嘛，即便是子女，朋友，都不可以使用。

　　3、**protected：**protected对于子女、朋友来说，就是public的，可以自由使用，没有任何限制，而对于其他的外部class，protected就变成private。

作用域	当前类	同一package	子孙类	其他package
public	√	√	√	√
protected	√	√	√	×
friendly(默认)	√	√	×	×
private	√	×	×	×

一个类可以包含以下类型变量:

局部变量:在方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
成员变量:成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化(分配内存)。成员变量可以被类中的方法和特定类的语句访问。
类变量:类变量也声明在类中，方法体之外，但必须声明为static类型。static也是修饰符的一种。

　　同时类也可以被final修饰，下面将会讲解finnal关键字和static关键字

比较	成员变量	局部变量
作用域	整个类中起作用（包括方法中）	只在方法中起作用
初始值	byte,short,int,long型是0 float,double型是0.0 char型是’\0’ boolean型是false	没有初始值，无法使用

　　注：当局部变量与成员变量重名时，在方法中优先使用局部变量，方法中使用成员变量使用this，this代表当前类的当前对象。

static(静态)

　　类的静态成员不依赖类的某一实例，可使用类名直接访问

１.静态变量（类变量）

当类第一次被加载（任何一个对象的声明，首先要加载类），该类的静态变量就分配独立内存，直到程序结束被回收。静态成员是公共的。（局部变量不能用static修饰）

比较	静态变量	成员变量
作用域	当前类	当前类
生命周期	类加载到程序结束	从对象产生到对象回收
使用方法	类名.静态变量名	对象名.成员变量名

　　静态变量即类变量 成员变量即实例变量，对象实例化后才能使用

静态方法

访问静态方法：类名.方法名(参数列表)

　　静态方法在同一个类中被调用时，类名可以省略。普通成员方法必须在对象实例化后才可以调用

比较	静态方法	成员方法
调用	类名.方法名(参数)	对象名.方法名(参数)
调用普通方法	不能直接调用	同一个类中可以调用
调用静态方法	类名.方法名(参数)	类名.方法名(参数)
访问静态变量	类名.静态变量名	类名.静态变量名
访问成员变量	不能直接访问	同一类中可以直接访问
this关键字	不能使用	可以使用

static代码块

　　static关键字还有一个比较关键的作用就是用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会在类加载的时候执行一次。

　　一般用来加载静态资源比如加载图片，视频，音频等。

final

Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。

1.修饰类

　　当用final修饰一个类时，表明这个类不能被继承。也就是说，如果一个类你永远不会让他被继承，就可以用final进行修饰。final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。

　　注：在使用final修饰类的时候，要注意谨慎选择，除非这个类真的在以后不会用来继承或者出于安全的考虑，尽量不要将类设计为final类。

修饰方法

　　使用final方法的原因有两个。
　　　第一个原因是把方法锁定，以防任何继承类修改它的含义；
　　　第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升。在最近的Java版本中，不需要使用final方法进行这些优化了。

　　注：类的private方法会隐式地被指定为final方法。

修饰变量

　　修饰变量是final用得最多的地方，也是重点阐述的内容

　　对于一个final变量，

　　　　如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；

　　　　如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。

类的final变量和普通变量有什么区别
- 当用final作用于类的成员变量时，成员变量（注意是类的成员变量，局部变量只需要保证在使用之前被初始化赋值即可）必须在定义时或者构造器中进行初始化赋值，而且final变量一旦被初始化赋值之后，就不能再被赋值了。

public class Test {
    public static void main(String[] args)  {
        String a = "hello2"; 
        final String b = "hello";
        String d = "hello";
        String c = b + 2; 
        String e = d + 2;
        System.out.println((a == c));//true
        System.out.println((a == e));//false
    }
}

分析
　　为什么第一个比较结果为true，而第二个比较结果为fasle。这里面就是final变量和普通变量的区别了，当final变量是基本数据类型以及String类型时，如果在编译期间能知道它的确切值，则编译器会把它当做编译期常量使用。也就是说在用到该final变量的地方，相当于直接访问的这个常量，不需要在运行时确定。这种和C语言中的宏替换有点像。因此在上面的一段代码中，由于变量b被final修饰，因此会被当做编译器常量，所以在使用到b的地方会直接将变量b 替换为它的值。而对于变量d的访问却需要在运行时通过链接来进行。想必其中的区别大家应该明白了，不过要注意，只有在编译期间能确切知道final变量值的情况下，编译器才会进行这样的优化，比如下面的这段代码就不会进行优化：

public class Test {
    public static void main(String[] args)  {
        String a = "hello2"; 
        final String b = getHello();
        String c = b + 2; 
        System.out.println((a == c));//这段代码的输出结果为false。

    }

    public static String getHello() {
        return "hello";
    }
}

被final修饰的引用变量指向的对象内容可变吗
- 引用变量被final修饰之后，虽然不能再指向其他对象，但是它指向的对象的内容是可变的。

public class Test {
    public static void main(String[] args)  {
        final MyClass myClass = new MyClass();
        System.out.println(++myClass.i);//结果为1
    }
}

class MyClass {
    public int i = 0;
}

final参数的问题
- 无论参数是基本数据类型的变量还是引用类型的变量，使用final声明都不会防止你无意的修改而影响到调用方法外的变量

public class Test {
    public static void main(String[] args)  {
        MyClass myClass = new MyClass();
        StringBuffer buffer = new StringBuffer("hello");
        myClass.changeValue(buffer);
        System.out.println(buffer.toString());
    }
}

class MyClass {

    void changeValue(final StringBuffer buffer) {
        buffer.append("world");
    }
}

　　运行这段代码就会发现输出结果为 helloworld。很显然，用final进行修饰并没有阻止在changeValue中改变buffer指向的对象的内容。有人说假如把final去掉了，万一在changeValue中让buffer指向了其他对象怎么办。有这种想法的朋友可以自己动手写代码试一下这样的结果是什么，如果把final去掉了，然后在changeValue中让buffer指向了其他对象，也不会影响到main方法中的buffer，原因在于java采用的是值传递，对于引用变量，传递的是引用的值，也就是说让实参和形参同时指向了同一个对象，因此让形参重新指向另一个对象对实参并没有任何影响。

static final

　　static作用于成员变量用来表示只保存一份副本，而final的作用是用来保证变量不可变。
　　static final修饰的属性表示一旦给值，就不可修改，并且可以通过类名访问。
　　static final也可以修饰方法，表示该方法不能重写，可以在不new对象的情况下调用。

方法

为什么要有方法
- 提高代码的复用性
什么是方法
- 完成特定功能的代码块。
方法的格式

修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
            方法体语句;
            return 返回值; 
        }

方法的格式说明
- 修饰符：一般就用 public，static，final。
- 返回值类型：就是功能结果的数据类型。
- 方法名：符合命名规则即可。方便我们的调用。
- 参数：
  - 实际参数：就是实际参与运算的。
  - 形式参数；就是方法定义上的，用于接收实际参数的。
- 参数类型：就是参数的数据类型
- 参数名：就是变量名
- 方法体语句：就是完成功能的代码。
- return：结束方法的。
- 返回值：就是功能的结果，由return带给调用者。

构造方法（特殊的方法）

　　在类实例化的过程中自动执行的方法叫做构造方法，它不需要你手动调用。构造方法可以在类实例化的过程中做一些初始化的工作。

　　构造方法的名称必须与类的名称相同，并且没有返回值。

　　每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认的构造方法。

public class Dog
{
  String name;
  int age;

  //构造方法，没有返回值
  Dog(String name1,int age1)
  {
     name = name1;
     age = age1;
     System.out.println("感谢主人领养了我");
  }

  //普通方法,必须有返回值
  void bark()
  {
     System.out.println("汪汪，不要过来");
  }

  void hungry()
  {
      System.out.println("主人，我饿了");
  }

  public static void main(String[] args)
  {
      //创建对象时传递的参数要与构造方法参数列表对应
      Dog myDog = new Dog("花花",3);
  }
}

运行结果：

感谢主人领养了我

package day23;
/*构造方法
 - 作用是用于初始化参数
 - 所有的数字变量全部设置为0
 - 所有的boolean类型全部设置为false
 - 所有的对象变量全部设置为null
 */
/*
 - 设计自己的构造方法
 -   方法名称必须和类的名称相同
 -   没有返回值
 */
/*
 - 如果自己写了有参的构造方法，那么编译器不会再提供
 - 默认的构造方法了
 - 如果我们还想用无参的构造方法，
 - 那么需要手动实现
 */
public class People 
{
    String name;
    String sex;
    int age;

    //无参的构造方法(可以不写编译器自动加上，前提是没有任何其他构造方法)
    People()//构造方法（可删掉,编译器默认加上)
    {
//      name = null;
//      sex = null;
//      age = 0;
    }

    //有参的构造方法
    People(String name,String sex,int age)
    {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    //部分初始化
    People(String name)
    {
        this.name = name;
    }

    People(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    public static void main(String[] args)
    {
        People p = new People();
        System.out.println(p.name);
        System.out.println(p.sex);
        System.out.println(p.age);

        People p1 = new People("张三","男",30);
        System.out.println(p1.name+","+p1.sex+","+p1.age);

        People p2 = new People("老王");
        System.out.println(p2.name);

        People p3 = new People("小老虎",3);
        System.out.println(p3.name+","+p2.age);
    }
}

说明:

构造方法不能被显式调用。
构造方法不能有返回值，因为没有变量来接收返回值

创建对象

　　对象是类的一个实例，创建对象的过程也叫类的实例化。对象是以类为模板来创建的。
　　在Java中，使用new关键字来创建对象，一般有以下三个步骤:

声明:声明一个对象，包括对象名称和对象类型
实例化:使用关键字new来创建一个对象。
初始化:使用new创建对象时，会调用构造方法初始化对象。
例如:

Dog myDog;//声明一个对象
myDog = new Dog("花花",3);//实例化

也可以在声明的同时进行初始化:

Dog myDog = new Dog("花花",3);

访问成员变量和方法

通过已创建的对象来访问成员变量和成员方法，例如:

//实例化
Dog myDog = new Dog("花花",3);
//通过点号访问成员变量
myDog.name;
//通过点号访问成员方法
myDog.bark();

　　下面的例子演示了如何访问成员变量和方法:

public class Dog
{
  String name;
  int age;

  Dog(String name1,int age1)
  {
     name = name1;
     age = age1;
     System.out.println("感谢主人领养了我");
  }

  void bark()
  {
    System.out.println("汪汪，不要过来");
  }

  void hungry()
  {
    System.out.println("主人，我饿了");
  }

  public static void main(String[] args)
  {
    Dog myDog = new Dog("花花",3);
    //访问成员变量
    String name = myDog.name;
    int age = myDog.age;
    System.out.println("我是一只小狗，我名字叫" + name + ",我" + age + "岁了");
    //访问方法
    myDog.bark();
    myDog.hungry();
  }
}

　运行结果：
　　　感谢主人领养了我
　　　我是一只小狗，我名字叫花花，我3岁了
　　　汪汪，不要过来
　　　主人，我饿了

　　这些就是面向对象的基础知识，下来难一点的比如抽象类，接口，重载，重写等，我会在下一篇将。

java面向对象（一）