面向对象

　　我们都说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。

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

• 局部变量:在方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。

• 成员变量:成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化(分配内存)。成员变量可以被类中的方法和特定类的语句访问。

• 类变量:类变量也声明在类中，方法体之外，但必须声明为static类型。static也是修饰符的一种。

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

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

static(静态)

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

１.静态变量（类变量）

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

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

静态方法

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

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

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岁了
　　　汪汪，不要过来
　　　主人，我饿了

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