Java面向对象笔记1

面向对象的思想概述

类（Class）和对象（Object）是面向对象的核心概念

• 类是对一类事务的描述，是抽象的、概念上的定义

• 对象是实际存在的该类事务的每个个体，因而也称为实例（instance）

---

一、Java面向对象的三条主线：

1. Java类及类成员：属性、方法、构造器；代码块、内部类

2. 面向对象及三大特征：封装、继承、多态、（抽象性）

3. 其他关键字：this、super、static、abstract、interface、package、import

二、面向对象的两个要素

类：对一类事务的描述，是抽象的、概念上的定义

对象：是实际存在的该类事务的每个个体。因而也称为实例

Java类及其类的成员：

• 属性：对应类中的成员变量

• 行为：对应类中的成员方法

一、设计类，其实就是设计类的成员

属性=成员变量=field=域、字段

方法=成员方法=函数=method

创建对象=类的实例化=实例化类

二、类和对象的使用（面向对象思想的落地的实现）

1. 创建类，设计类的成员

2. 创建类的对象

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

class Person{
//属性
    String name;
    int age;
    boolean isMale;
//方法
    public void eat(){
        System.out.println("人可以吃饭")
    }
}

三、如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）

意味着：如果我们修改一个对象的的属性a，则不影响另外一个对象属性a的值

四、对象的内存解析

• 堆（Heap），此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。这一点在Java虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配。

• 通常所说的栈（Stack）是指虚拟机栈。虚拟机栈用于存储局部变量局部变量表存放了编译期可知长度的各种基本数类型（Boolean、byte、char、short、int、float、long、double）对象引用（reference类型，他不等同于对象本身，是对象在堆内存的首地址）。方法执行完，自动释放

• 方法区（Method Area），常用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据

• 创建类，设计类成员

class Person(){
    //属性
    String name;
    int age=1;
    boolean isMale;
    //方法
    public void eat(){
    System.out.printle("人可以吃饭")
    }
    
    publicvoid sleep(){
    System.out.println("人可以睡觉")；
    }
    
    public void talk(String language){
    System.out.println("人可以说话，使用的是"+language);
    }
}

类中属性的使用

属性（成员变量）vs局部变量

1. 相同点

   1. 定义变量的格式：数据类型 变量名=变量值

   2. 先声明，后使用

   3. 变量都有其对应的作用域

2. 不同点

   2.1、在类中声明的位置不同

   属性：直接定义在类的一对{}内

   局部变量:声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量

   2.2、关于权限修饰符的不同

   属性：可以在声明属性时，指明其权限，使用权限修饰符

   常用的权限修饰符：private、public、缺省、protected

   2.3、默认初始化值得情况：属性：类的属性，根据其类型，都有默认初始化值。

   整形（byte、short、int、long）：0

   浮点型（float、double）：0.0

   字符型（char）：0（或’\u0000）

   布尔型（boolean）：false

   引用数据类型（类、数组、接口）：null

   局部变量：没有默认初始化值

   意味着，我们在调用局部变量之前，一定要显示赋值。

   特别的：形参在调用时，我们赋值即可

        2.4、在内存中加载的位置：

        属性：加载到对空间中（非static）

        局部变量：加载到堆空间

类中方法的声明和使用

方法：描述类应该具有的功能。

比如：Math类：sqrt()\random()\...

Scanner类：next Xxx()\....

Arrays类：sort()\binarySerch()\toString()equals()...

1.举例：

public void eat(){}

public void sleep(int hour){}

public String getName(){}

public String getNation(String nation){}

2.方法的声明：权限修饰符 返回值类型 方法名（形参列表）{
​
    方法体
​
}

3.说明：

        3.1、关于权限修饰符：

        Java规定的4种权限修饰符：private、public、缺省（当你使用一个没有赋值的变量时，程序没有报错，则这个变量有缺省值。例：定义一个int类型的变量，输出得到0，则0为int类型的缺省值）、protected

        3.2、返回值类型：有返回值，则必须再方法申明时，指定返回值的类型。同时，方法种需要使用return关 键字来返回指定类型的变量或常量

        3.3、方法名：属于标识符，遵循标识符的规则和规范，“见名只意”

四、数组对象

一、理解“万事万物皆对象”

1. 再Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构

2. 涉及到Java语言于前端Html、后端的数据库交互时，前后端的结构再Java层面交互时，都体现为类、对象。

二、内存解析的说明

1. 引用类型的变量，之可能存储两类值：null或其他地址值（含变量的类型）

三、匿名对象的使用

五、自定义数组的工具类

//求数组的最大值
public int getMax(int[] arr){
   int maxValue=arr[0];
    for(int i=1;i<arr.length;i++){
        if(maxValue<arr[i]){
            maxValue=arr[i];
        }
    }
    return maxValue;
}
//求数组的最小值
public  int getMin(int[] arr){
    int minValue=arr[0];
    for(int i=1;i<arr.length;i++){
        if(minValue>arr[i]){
            minValue=arr[i];
        }
    }
    return minValue;
}
//求数组的总和
public int getSum(int[] arr){
    int sum=0;
    for(int i=0;i<arr.length;i++){
        sum+=arr[i];
    }
    return sum;
}
//求数组的平均值
public int getAvg(int[] arr){
    return getSum(arr)/arr.length;
}
//反转数组
public void reverse(int[] arr){
    //方法一：
    for(int i = 0;i<arr.length/2;i++){
        int temp=arr[i];
        arr[i]=arr[arr.length-i-1];
        arr[arr.length-i-1]=temp;
    }
    
    //方法二：
    fro(int i=0,j=arr,length-1;i<j;i++,j--){
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
}
//复制数组
public int[] copy(int[] arr){
    int[] arr1=new int[arr.length];
    for(int i=0;i<arr1.length;i++){
        arr1[i]=arr[i];
    }
    return arr1;
}
//数组排序
public void sort(int[] arr){
    //冒泡排序
    for(int i=0;i<arr.length-1;i++){
        for(int j=0;j<arr.length-1-i;j++){
            if(arr[j]>arr[j+1]){
                int temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }
    }
}
//遍历数组
public void print(int[] arr){
    for(int i=0;i<arr.length;i++){
        System.out.print(arr[i]+"\t");
    }
    System.out.println();
}
//查找指定元素
public int getIndex(int[] arr,int dest){
    for(int i=0;i<arr.length;i++){
        //此处注意！！！当为int型则用==，为其他类型则考虑用equals
        //public int getIndex(int[] arr,int dest){
        //for(int i=0;i<arr.length;i++){
            //if(dest==arr[i]){
        //  return i;
        //      }
        //  }
        //  return -1;
        //}
        
        if(dest.equals(arr[i])){
            System.out.println("找到了指定的元素，位置为："+i);
            isFlag=false;
            break;
        }
    }
    if(isFlag){
        System.out.println("跟遗憾，没有找到啦!");
    }
    return 0;
}

六、理解方法的重载

方法的重载

"两同一不同"：同一个类、相同方法名。不同：参数列表不同，参数个数不同，参数类型不同

重载的概念：在同一个类中，允许存在一个以上的同名方法，只要他们的参数个数或者参数类型不同即可

重载的特点：与返回值类型无关，只看参数列表，且参数列表必须不同。（参数个数或参数类型）。调用时，根据方法参数列表的不同来区别。

总结：在通过对象调用方法时，如何确定某一个指定的方法：

1. 方法名

2. 参数列表

重载示例：

//返回两个整数的和
int add(int x,int y){return x+y};
//返回三个整数的和
int add(int x,int y,int z){return x+y+z};
//返回两个小数的和
doubule add(double x,double y){return x+y};

可变形参的方法

JavaSE 5.0中提供了Varargs（variable number of arguments）机制，允许直接定义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可变的实参。

具体使用：

1. 可变个数形参的格式： 数据类型...变量名

2. 当调用可变数形参的方法时，传入的参数个数可以是：0个，1个，2个

3. 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载

4. 可变个数形参的方法与本类方法名想同，形参类型也相同的数组之间不构成重载（二者不能共存）

5. 可变个数形参在方法的形参中，必须声明在末尾

6. 可变个数形参在方法的形参中，最多只能声明一个可变形参

方法参数的值传递机制

方法，必须由其所在类或对象调用才有意义。若方法含有参数：

• 形参：方法声明时的参数

• 实参：方法调用时实际传给形参的参数值

Java的实参值如何传入方法呢？

Java里方法的参数传递方式只有一种：值传递。即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。

• 形参是基本数据类型：将实参基本数据类型变量的”数据值“传递给形参

• 形参是引用数据类型：将实参引用数据类型变量的”地址值“传递给形参

关于变量的赋值：

• 如果变量是基本数据类型，此时赋值的变量所保存的数据值

• 如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值

方法的形参的传递机制：值传递

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

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

• 值传递机制：

  如果参数时基本数据类型，此时赋值的是变量所保存的数据值

  如果参数数引用数据类型，此时赋值的是变量所保存的数据的地址值

递归方法

• 递归方法：一个方法体内调用它自身

• 方法递归包含一种隐式的循环，它会重复执行某段代码，但这种重复执行无需循环控制

• 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。