面向对象（上）

一、java面向对象学习的三条主线

1.java类及类的成员：属性、方法、构造器；代码块、内部类
2.面向对象的三大特征：封装性、继承性、多态性（抽象性）。
3.其他关键字:this、super、static、final、abstract、interface、package、import等。

二、面向过程和面向对象的对比 

1.面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做
2.面向对象:强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

三、面向对象的两个要素：

类（Class）和对象（Object）是面向对象的核心概念
类：对一类事物的描述，是抽象的、概念上的定义。
对象：是实际存在的该类事物的每个个体，因而也称为实例（instance）
>面向对象程序设计的重点是类的设计
>设计类，就是设计类的成员

一、设计类，其实就是设计类的成员
属性=成员变量=field=域、字段
方法=成员方法=函数=method
创建类的对象=类的实例化=实例化类
二、类和对象的使用
1.创建类、设计类的成员
2.创建类的对象

class Person{
    //属性：对应类中的成员变量
         String name;//姓名
         int age=1;//年龄
         boolean isMale;//判断是否为男性
    //方法：对应类中的成员方法
    public  void eat(){
        System.out.println("人可以吃饭");
    }
    public void sleep(){
        System.out.println("人可以睡觉");
    }
    public void talk(String language){
        System.out.println("人可以说话，使用的是："+language);
    }

}

3.通过“对象.属性”或“对象.方法“调用对象的结构

public static void main(String[] args) {
        //创建Person类的对象
        Person p1=new Person();
        //调用对象的结构：属性、方法
        //调用属性“对象.属性”
        p1.name="梁伟";
        p1.isMale=true;
        System.out.println(p1.name);//输出姓名
        //调用方法：“对象.方法”
        p1.sleep();
        p1.talk("汉语");
        Person p2=new Person();
        System.out.println(p2.name);//null(空值)
        Person p3=p1;//将p1变量保存的对象地址值赋给p3，导致p1和p3指向了堆空间中的同一个对象实体。
        System.out.println(p3.name);
        p3.age=10;//p3.age修改为10，p1.age输出也是10
        System.out.println(p1.age);
    }

三、如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（static的）
意味着，如果我们修改一个对象的属性a，则不影响另一个对象的属性。
四、对象的内存解析

编译完程序以后，生成一个或多个字节码文件

我们使用JVM中的类的加载器和解释器对生成的字节码文件进行解释运行。意味着，需要将字节码文件对应的类加载到内存中，涉及到内存的解析。

《JVM规范》

虚拟机栈，即平时提到的栈结构。我们将局部变量存储在栈结构中。

堆，我们将new出来的结构（比如：数组、对象）加载在堆空间中。补充：对象的属性（非static的）加载在堆空间中

方法区：类的加载信息、常量池、静态域。

类中属性的使用

属性（成员变量）vs局部变量
1.相同点：
       1.1定义变量的格式：数据类型 变量名=变量值
       1.2先声明、再使用
       1.3变量都有其对应的作用域
2.不同点：
       2.1在类中声明位置的不同
       属性：直接定义在类的{}内
       局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
       2.2关于权限修饰符的不同
       属性：可以在声明属性时，指明其权限，使用权限修饰符
       常用的权限修饰符：private、public、缺省、protected
       2.3默认初始值的情况。
       属性：类的属性，根据其类型，都有默认初始化值。
       整型（byte、short、int、long），0
       浮点型（float、double），0.0
       字符型（char），0或（'\u0000')
       布尔型（boolea），false

       引用数据类型（类、数组、接口），null
     局部变量：没有默认初始化值。
     意味着我们调用局部变量时一定要显示赋值。
     2.4在内存加载的位置。
     属性：加载到堆空间中（非static）
     局部变量：加载到栈空间

类中方法的声明和使用

方法：描述类应该具有的功能
比如：Math类：sqrt（）\random（）\...
     Scanner类：nextxxx()...
     Arrary类：sort（）、binarySearch、toString（）、equals（）...
1.举例//void是没有返回值类型
public void eat(){
public void sleep(int hour){
public String getName(){
public String getNation(String nation){
2.方法的声明：权限修改符 返回值类型 方法名（形参列表）{
                                       方法体
        }
3.说明：
      3.1关于权限修饰符：
         java规定的四种权限修饰符： private、public、缺省、protected
      3.2返回值类型：有返回值\没有返回值

      3.2.1如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时方法中需要使用
      return关键字来返回指定类型的变量或者常量。
      如果方法没有返回值，则方法声明时，使用void来表示,通常没有返回值的方法中就不需要使用return，但是如果使用的话
      只能“return”，表示结束此方法的意思

      3.2.2我们定义方法该不该有返回值？
      ①题目要求
      ②凭经验，具体问题具体分析。

      3.3方法名：属于表示符、遵循标识符的规则规范
      3.4形参列表：方法可以声明0个，一个，或者多个形参。
      3.4.1格式：数据类型1 形参1，数据类型2 形参2，。。。

      3.4.2我们定义方法时，该不该定义形参？
      ①题目要求
      ②凭经验，具体问题具体分析。

      3.5方法体：方法功能的体现

      return关键字的使用：

      1.使用范围：使用在方法体中
      2.作用：①结束方法
             ②针对有返回值类型的方法，使用“return 数据”方法返回所要数值
      3.注意点： return关键字后面不可以声明执行语句

    5.方法的使用中可以调用当前类的属性或方法
         特殊的：方法A中又调用了方法A：递归方法
         方法中不可以定义方法

       匿名对象

说明：我们创建的对象，没有显示的赋给一个变量名，即为匿名对象

特征：匿名对象只能调用一次

举例：

        //匿名对象
        new Phone().sendEmail();
        new Phone().playGame();

        new Phone().price=1999;
        new Phone().showPrice();//0.0,说明重新new的是一个新的对象

    PhoneMall mall=new PhoneMall();
        //匿名对象的使用
        mall.show(new Phone());
  class PhoneMall{
    public  void show(Phone phone){
        phone.showPrice();
        phone.playGame();

    }

     理解“万事万物皆对象”

1.在java语言范畴中，我们都将功能结构等封装到类中，通过类的实例化来调用具体的功能结构
>Scanner，String等
>网络资源：URL
2. 涉及到java语言与前端Hteml、后端的数据库交互时，前后端的结构在java层面交互时，都体现为类、对象

      方法的重载（overload）

1.定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可
     总结：“两同一不同：同一个类、相同方法
                参数列表不同：参数个数不同、参数类型不同
2.举例：
       Arrays类中重载的sort()/binarySearch()
3.判断是否是重载：

         严格按照定义判断：两同一不同
       跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系
4.在通过对象调用方法时，如何确定某一个指定的方法：
              方法名---->参数列表

面试题：方法重载与重写的区别？

         可变个数形参的方法：

使用说明：
  1.jdk 5.0新增的内容
  2.具体使用：
  2.1可变个数形参的格式：数据类型...变量名
  2.2当调用可变个数形参方法时，传入的参数个数可以是：0个，1，多个。。。
  2.3可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载。
  2.4可变个数形参的方法与本类中方法名相同,形参类型也相同的数组之间不构成重载，换句话说，二者不能同时存在于一个类中
  2.5可变个数形参在方法的形参中，必须声明在末尾
  2.6可变个数形参在方法中，最多只能声明一个可变形参。

举例说明：

 public static void main(String[] args) {
        MethodArgsTest test=new MethodArgsTest();
        test.show(12);
        test.show("hello","word");
        test.show("ab","cd","ef");
    }
    public void show(int i ){

    }
    public void show(String s){
        System.out.println("show(String)");

    }
    public void show(String...strs){
        for (int i=0;i<strs.length;i++){
            System.out.println(strs[i]);
        }

    }
    //与可变个数形参方法名相同，不是重载
//    public void show(String[] strs){
//
//    }

        java的值传递机制

1.针对与方法内变量的赋值举例：

 public static void main(String[] args) {
        //基本数据类型：
        int m=10;
        int n=m;
        System.out.println("m="+m+"n="+n);
        n=20;
        System.out.println("n="+n);
        System.out.println("******************");

        //引用数据类型：
        Order o1=new Order();
        o1.orderID=1001;
        Order o2=o1;//赋值以后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体
        System.out.println("o1.orderID="+o1.orderID+",o2.orderID="+o2.orderID);
        o2.orderID=1002;
        System.out.println("o1.orderID="+o1.orderID+",o2.orderID="+o2.orderID);



    }

规则：
如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值

2.针对与方法的参数概念

形参：方法定义时，声明的小括号内的参数

实参:  方法调用时，实际传递给形参的数据

3.java中参数传递机制：值传递
如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。

典型例题与内存解析：

【例题一】

【例题二】 

 递归方法的使用：

1.定义：

递归方法：一个方法体内调用它自身
2.如何理解递归方法？

方法递归包含了一种隐式的循环，它会重复执行某段代码，但是这种重复执行无须循环控制。
递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。

3.举例：

  //求1-100直接所有自然数的合
//方式二：递归方法
        RecursionTest tese=new RecursionTest();
        int sum1=tese.getsum(100);
        System.out.println(sum1);
    }
    public int getsum(int n){
        if(n==1){
            return 1;
        }else{
            return n+getsum(n-1);
        }
    }
}