面向对象

方法(面向对象)

1.概念

执行特定业务逻辑操作的结构体，在Java中称为方法，在C语言中称为函数

2.语法

访问修饰符 返回值类型 方法名([参数列表]){

方法体（执行特定操作的内容）

}

方法4要素：

访问修饰符：public static |private(私有)|protected（受保护）|默认

返回值：方法的返回结果类型，类型可以是：引用类型，基本数据据类型

方法名：自定义，命名规则和变量相同

参数列表：可有可无 ，没有参数称为无参数法，反之有参数方法，方法称为形式上的参数

注意：如果方法有返回值：则必须用return结束

方法调用

形式1：直接调用

被调用方法名（[实参列表]）

形式2：输出调用

System.out.println （方法（[实参列表]）

形式3：赋值调用

数据类型 变量名=方法（[实参列表]）

注意：1，方法调用时的阐述列表（数量，数据类型，先后顺序）必须和方法定义时的参数列表约束一致。

2，返回值：如需对返回值进行赋值，则赋值变量的数据类型一定和方法定义时的返回值类型吻合

方法重载

条件

1.在同一个类中

2.方法名相同

3.参数列表不同

4.与返回值和访问修饰符没有关系

意义：为了更好的解决方法名相同的情况下，执行不同的业务操作。

一维数组

1.概念

用于存储一种相同数据类型的变量（容器），这就是数组。

2.声明格式

1，数据类型 数组名【】

2，数据类型【】数组名

3.初始化方式

1，动态初始化：定义数组长度，由系统自动为数组赋初始值。

格式：数据类型 数组名【】=new 数据类型【数组长度】；

2，静态初始化；给定数组赋初始值，系统决定长度

格式一：数据类型 数组名【】=new 数据类型【】{元素1，元素2.。。。。元素n}；

格式二：数据类型 数组名【】={元素1，元素2.。。。。元素n}；

数组元素值的获取与设置

格式：数组名[索引] = 赋值内容； //设置数组元素内容

数组名[索引]; //获取数组元素内容

注意：索引从0开始，数组最⼤索引为数组⻓度-1；如果索引超出边界值，则报索引越界异常；

内存分布

栈（stack）：存放的都是⽅法中的局部变量，⽅法的运⾏⼀定要在栈中运⾏。

局部变量：⽅法的参数或者是定义在⽅法体内的内部变量；

作⽤于：⼀旦超出作⽤于，⽴刻从栈内存当中消失。

堆（heap）: 凡事new出来的内容，都是在堆内存中。

堆内存储的元素都是⼀个个的地址值：16进制

堆内存中的元素都是有默认值的：规则如下：

整数 0

浮点数 0.0

字符 ‘\u0000’

Boolean false

引⽤类型 null

⽅法区（method area）：存储.class 相关的信息，包含⽅法的信息

本地⽅法区（native method area）：与操作系统相关 此阶段了解即可

寄存器：与CPU 相关，此阶段了解即可

常见操作

1.数组元素遍历

package array;

import java.util.Scanner;

public class ArrayDemo1 {
    public static void main(String[] args){
        //1.创建键盘录入对象
        Scanner name1=new Scanner(System.in);//Scanner 后面可以跟字符串
        //控制台提示输入班级学院数量
        System.out.println("输入王者4班学员的数量");
        //定义用于存储学员数量的变量
        int num=name1.nextInt();
        //2.动态创建用于存储学员姓名的容器
        String name[]=new String[num];
        //3.动态为数组元素赋值
        for(int i=0;i<num;i++){
            System.out.print("请输入第："+(i+1)+"名学员的姓名");
            name[i]=name1.next();
            System.out.println();
        }
        System.out.println("学员信息如下：");
        //4.遍历数组并输出数组元素
        for(int i=0;i<num;i++){
            System.out.println(name[i]);
        }
    }
}

2.求最值

package array;

import java.util.Scanner;

public class ArrayDemo2 {
    public static void main(String[] args){
        //1.创建键盘录入对象
        Scanner input=new Scanner(System.in);
        //2.控制台提示输入班级学院数量
        System.out.print("输入王者4班班级人数：");
        int num=input.nextInt();
        //3.创建用于存储学员姓名的容器并且动态开辟空间，空间大小决定班级人数
        int score[]=new int[num];
        //4.循环遍历数组并且为数组每一个元素进行动态赋值
        for(int i=0;i<num;i++){
            System.out.print("请输入第："+(i+1)+"成绩");
         score[i]=input.nextInt();
//            System.out.println();
        }
        //5.求最值
        int max= score[0];
        int min= score[0];
        for(int i= 1;i<num;i++){
            if(score[i]>max){
                max=score[i];
            }else{
                min=score[i];
            }
        }
        System.out.print("最大值"+max);
        System.out.print("最小值"+min);

    }
}

3.逆序

package array;

public class ArrayDemo3 {
    public static void main(String[] args) {
        int arr[]={10,20,70,5,100};
        for(int min=0,max=arr.length-1;min<max;min++,max--){
            int temp=arr[min];
            arr[min]=arr[max];
            arr[max]=temp;
        }
        System.out.println("交换后的值");
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+"\t");
        }
    }
}

4.查找元素

package array;

import java.util.Scanner;

public class ArrayDemo4 {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        String names[] = new String[]{"tom","赵童","唐康","王必武"};
        System.out.println("输入名字：");
       String name =sc.next();
        boolean flag = false;
        for(int i=0;i<4;i++){
            if(names[i].equals(name)){
                System.out.println("恭喜找到了");
                flag = true;
                break;
            }



            }
        if(!flag){
            System.out.println("没找到");


        }





    }
}

二维数组

构成：在一维数组的基础上惊醒的扩展，即一维数组的每一个元素也是一个一维数组，其实在Java中不存在二维数组的结构。

int school[][] = new int[5][];//开启最大维度的长度
school[0]=new int[5];//开启二维数组第一个最大维度元素空间

格式一：

数据类型【】【】 变量名= new 数据类型【m][n];

//m:二维数组中可以存取一维数组的个数

//n:一维数组长度

格式二:

数据类型【】【】 变量名= new 数据类型【m][];

m:二维数组中可以存储一维数组的个数

一维数组的长度由动态进行指定

格式三：

数据类型【】【】 变量名= new 数据类型【】【】{元素一，元素二，。。。。元素n}{元素一，元素二，。。。。元素n};

简化格式：

数据类型（【】【】）变量名（【】【】）={元素一，元素二，。。。。元素n}{元素一，元素二，。。。。元素n};

【】【】可以放在变量名后面

二维数组的遍历

分析：

1.遍历二维数组中存储的一维数组个数。

2.遍历二维数组中每一个一维数组中的元素。

提取二维数组中的每一个一维数组：arr[索引]

遍历当前一维数组：

3.二维数组的遍历 外层循环控制二维数组的最大维度长度，内层循环控制一维数组长度

int[][] school={{1,2,3},{4,5},{6,7,8,9}};
for(int i=0;i<school.length;i++)
for(int j=0;j<school[i].length;j++){
System.out.print(school[i][j]);
}
}

/**
 * 二维数组的应用:
 * 需求:动态录入若干个班级若干名学员的考试成绩，并求出每个班级的总成绩、平均成绩分析:若干个班级需要一个 数组进行存储
 * 若干名学员需要一个数组进行存储
 * 若干个班级若干名需要一个二维数组
 * 班级管理制度
 * 若干个:需要通过键盘录入对象scnner进行动态录入
 * 录入每个班级每个学员的成绩:需要遍历二维数组
 * 计算总成绩、平均成绩:需要将录入元素后的二维数组进行遍历，并计算成绩。
 */
//
public class Array2Demo {
    public static void main(String[] args){
//        //1.创建键盘接收对象
       Scanner sc= new Scanner(System.in);
//        //2.动态录入班级数量
//        //3.创建一个用于存储若干名学员考试成绩的二维数组并开辟最大维度空间
          //4.循环遍历二维数组中每一个一维数组并为其开辟空间（每个班级学员数量）
//        //5.循环遍历每一个一维数组的元素并动态录入考试成绩（内层循环开启）
//        //6.求出当前班级总成绩，此时内层循环已结束
//        //7.在外层循环里，内城循环外计算当前班级的平均成绩并输出
        System.out.println("输入班级数；");
        int num=sc.nextInt();
        int scores[][]=new int[num][];
        for(int a=0;a<num;a++){
            System.out.println("第："+(1+a)+"班的数量：");
            int num1=sc.nextInt();
           scores[a]=new int[num1];
//            int scores[][]=new int[num][num1];
            int sum=0;
            for(int b=0;b<num1;b++){
                System.out.println("这个班第"+(1+b)+"成绩是：");
                scores[a][b]=sc.nextInt();
                sum+=scores[a][b];
            }
            System.out.println("总成绩"+sum+"分");
            System.out.println("总成绩"+sum/num1+"分");
//            System.out.println();
        }

    }
}

面向对象

1.思想

2.面向过程和面向对象的区别

面向过程

特点：具体的每一步都是参与者，关注的是解决问题的过程

面向对象

特点：只关注最终结果

3.面向对象的特点：

1.更符合人们思考问题的方式

2.将我们从执行者变为调用者

3.将问题简化

4.举例：把大象转入冰箱

分析：1.有哪些类：大象 冰箱 OPPDemo

2.每个类中都有哪些行为（方法）

大象类：吃草 走路

冰箱：开门 关门

OOPDemo:装大象的方法

3.类与类之间有怎样的关系

5.源码演示

public class ICEBox {
 public static void openDoor(){
 System.out.println("打开冰箱⻔");
 }
 public static void closeDoor(){
 System.out.println("关上冰箱⻔");
 }
}

public class OOPDemo {
 public static void putin(Elephant elephant){
 System.out.println("装⼤象");
 }
 public static void main(String[] args) {
 //如果使⽤⾯向过程的思想解决此问题
 System.out.println("打开冰箱⻔");
 System.out.println("装⼊⼤象");
 System.out.println("关闭冰箱⻔");
 System.out.println("_________________");
 //使⽤⾯向对象的思想解决此问题
 //调⽤冰箱的开⻔⾏为
 ICEBox.openDoor();
 //装⼊⼤象
 putin(new Elephant());
 //调⽤冰箱的关⻔⾏为
 ICEBox.closeDoor();
 }
}

6.面向对象开发设计与特征

开发：不断地创建对象，使用对象，修改对象

设计：管理和维护对象之间的关系。一个好的对象设计，可以实现程序的简化并且易于保护

特征：封装，继承，多态

7.类和对象

类：具有相同属性特征和行为动作的一类事物，统称为类，看不见，摸不着，只是一个抽象的概念。

对象：万事万物皆对象：看得见摸得着

类和对象关系：对象是类具体描述，类是对象的抽象。

属性：描述该事物具有的信息

行为：该事物能干什么

注：Java中最基本的单位：类。所以我们应该尝试用类来描述事物‘

事物 类

属性 成员变量

行为 成员方法

8.类的使用

定义：

访问修饰符 class 类名{

成员变量

构造⽅法（⽆参、有参），默认存在⼀个隐形的⽆参构造⽅法

成员方法

}

public class Student {
    //成员变量
    String name;
    int age;
    String email;
    String address;
    //  构造⽅法（⽆参、有参）
    public Student(){

    }
    public Student(String name,int age,String email,String address){
        this.name=name;
        this.age=age;
        this.email=email;
        this.address=address;
    }

    //成员方法
    public String getName(){
        return name;
    }
    //设置姓名
    public void setName(String name){

        this.name=name;
    }
    //设置并获取年龄
    public int getAge(int age){
        if(age>0&&age<16){
            this.age = 16;
        }else{
            this.age=age;
        }
        return this.age;

    }


}

类的调用：

1.实例化类 语法：类名 对象名 = new 类名（）；学生类 Tom=new 学生类()

​ 类名 对象名 = new 类名（【实参列表】）；

2.调用类中的属性：对象名.属性名Tom.name

3.调用类中的方法：对象.方法名（【实参列表】）；

构造方法：⽤于实例化类的对象的⽅法称为构造⽅法

分为：有参构造⽅法：实例化对象的同时为类中的成员属性进⾏赋值

⽆参构造⽅法：实例化对象的时候对成员属性不进⾏赋值

语法格式：访问修饰符 ⽅法名(){//⽆参构造⽅法

}

访问修饰符 ⽅法名([形参列表]){

this.成员属性 = 形参；

…

}

注意：1. 构造⽅法名必须和其类名同名

2.没有返回值这⼀说法

3.如果在⼀个类中显示的定义了有参构造⽅法，则隐形⽆参构造将不存在。此时建议将 ⽆ 参构造⽅法显示定义

4.每个类都有构造⽅法，如果没有显示地为类定义构造⽅法，Java编译器将会为该类提供⼀个 默认隐形 ⽆参构造⽅法

5.在创建⼀个类的对象时，⾄少要调⽤⼀个构造⽅法

6.⼀个类中可以有多个构造⽅法，它们之间构成了重载，即构造⽅法重载

this：代表当前类的对象 ⽤途：

1.⽤于区分成员变量和局部变量同名冲突问题

2.可以调⽤当前类的构造⽅法。语法：this([参数列表]); 不传参数在调⽤当前类的⽆参构造⽅法，相反调 ⽤参数列表相吻合的有参构造⽅法。注意：此条调⽤语句必须是⽅法体中的第⼀⾏语句

3.可以调⽤成员属性：this.成员属性名

4.可以调⽤成员⽅法：this.成员⽅法名([参数列表]);

**
 * this 关键字的应⽤：
 * 1.调⽤当前类的属性(区分成员变量和局部变量同名赋值问题)
 * 2.调⽤当前类的⽅法
 * 3.调⽤当前类的其他构造⽅法
 * 注意：this关键字访问类的成员变量和成员⽅法时不受访问权限的控制，
 * 可以访问本类中所有的成员变量和成员⽅法，包括private 的成员变量
 *  和成员⽅法
 */

public class Person {
    String name;
    int age;
    // public Person(){
// this("tom");
// }
//
// public Person(String name){
// this();
// }
// //以上代码构成了死归问题，就是构造⽅法之间的调⽤没有退出条件
    public Person(){
        this("tom",20);
//        类的应⽤：
    }
    public Person(String name){
        this.name = name;
    }
    public Person(String name ,int age){
        //this.age = age;//此⾏代码是为了更好的演示this调⽤构造⽅法时必须为⾸⾏代码的举例
        //this(name);//编译错误：原因：this调⽤当前类中的其他构造⽅法时必须时⽅法体中的⾸
//⾏代码
        this(name);
        this.age = age;
    }
    public void setName(String name){
        this.name = name;
    }
    public void testMethod(String name){
        this.setName(name);//通过this调⽤了当前类中的其他⽅法
        System.out.println(this.name);
    }
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println("--------------this调⽤本类属性-----------------");
        person.setName("tom");
        System.out.println("name1:"+person.name);
        System.out.println("--------------this调⽤本类⽅法-----------------");
        person.testMethod("lily");
        System.out.println("--------------this调⽤本类构造⽅法-----------------");
        Person person1 = new Person("tom",30);
        System.out.println(person1.name);
        System.out.println(person1.age);
    }
}

类的应⽤：

public class Student {
    //成员变量
    String name;
    int age;
    String email;
    String address;
    public Student(){

    }
    public Student(String name,int age,String email,String address){
        this.name=name;
        this.age=age;
        this.email=email;
        this.address=address;
    }

    //成员方法
    public String getName(){
        return name;
    }
    //设置姓名
    public void setName(String name){

        this.name=name;
    }
    //设置并获取年龄
    public int getAge(int age){
        if(age>0&&age<16){
            this.age = 16;
        }else{
            this.age=age;
        }
        return this.age;

    }


}

public class StudentTest {
    public static void main(String[] args){
        //1.实例化Student类的对象
        Student zhaotong= new Student();
        //2.调用属性 对象名.属性名
        zhaotong.address="陕西";
        zhaotong.name="赵童";
        zhaotong.email="2036203483@qq.com";
        zhaotong.age=20;
        System.out.println("姓名："+zhaotong.name);
        System.out.println("年龄："+zhaotong.age);
        System.out.println("邮箱："+zhaotong.email);
        System.out.println("地址："+zhaotong.address);


        Student qubo = new Student("屈波",20,"111.com","重庆");
        System.out.println("姓名："+qubo.name);
        System.out.println("年龄："+qubo.age);
        System.out.println("邮箱："+qubo.email);
        System.out.println("地址："+qubo.address);
        //.调用成员方法 对象名.方法名
        int stuAge = qubo.getAge(25);
        System.out.println("stuAge:"+stuAge);
        System.out.println("姓名:"+qubo.getName());
        qubo.setName("tom");
        System.out.println("name="+qubo.getName());






    }
}

9.在一个类中可以有以下变量

类变量：存在于类中，方法之外，声明时必须前面加static关键字；如： static int flag;随着类的加载而产生

成员变量：

局部变量：

局部变量和成员变量的区别：

1.声明的位置不同

成员变量（实例变量）：类中，方法体外

局部变量：方法体中或方法声明上

2.内存中储存位置不同

成员变量：位于堆内存中

局部变量：位于栈内存中

3.生命周期不同

成员变量：随着对象的产⽣⽽产⽣，随着对象的消亡⽽消亡

局部变量：随着⽅法的调⽤⽽产⽣，随着⽅法调⽤完毕⽽结束

4.初始状态不同

成员变量：有默认的初始化值

局部变量：没有默认的初始化值，必须⼿动初始化后，才能使⽤。

5.执行优先级

当成员变量和局部变量同名时，调用时采取就近原则