华清远见-重庆中心-JAVA面向对象阶段技术总结/知识点梳理

方法

概念

一段独立的代码，能完成一件事情，可以被重复调用。

方法可以减少重复的代码。

如何调用方法

通常情况下，方法通过对象或类名使用".“操作符进行调用，也可能不用”."直接调用。

如

//sc就是Scanner类的一个对象
Scannser sc = new Scanner(System.in);
//通过对象sc调用Scanner类中的nextInt()方法
int inp = sc.nextInt();
//Arrays是一个类，这里通过类名调用
Arrays.sort(数组);

通过类名调用

Math类

Math类是Java提供的一个工具类，用于数学相关的运算。

其中的方法都是被static关键字修饰的静态方法，调用时，直接通过类名调用。

import java.util.Random;
  /*
  * 方法的概念
  *
  *
  * */
 public class FunctionTest {
   
  /*
  * 程序的入口，就是一个方法，称为主方法
  *
  * */
  	public static void main(String[] args) {
   
     //Math类的使用
     //Math类是一个数学工具类，包含了很多数学计算相关的方法
     //Math类中的方法都是被static修饰的静态方法，调用时直接通过Math类名访问

     //求绝对值
     int res = Math.abs(-5);
     System.out.println(res);
     //求最大值
     int max = Math.max(1, 5);
     System.out.println(max);
     //得到a的b次幂
     double num = Math.pow(2, 3);
     System.out.println(num);

     //开平方
     System.out.println(Math.sqrt(16));
     //开立方
     System.out.println(Math.cbrt(27));

     //四舍五入
     System.out.println(Math.round(2.4));
     //向上取整(小数部分是非零时，向前进一)  .1~.9都会进一
     System.out.println(Math.ceil(5.0));
     //向下取整(小数部分是非零时，去掉小数)  .1~.9都会去掉
     System.out.println(Math.floor(9.9));

     //round就是按数轴四舍五入向右取整
     System.out.println(Math.round(-1.5));//-1

     //得到[0,1)区间内的随机数
     System.out.println(Math.random());

     //得到[3,10)区间内的随机数
     //根据Math.random()生成[min,max)
     //Math.floor(Math.random()*(max-min)+min)

     //圆周率
     System.out.println(Math.PI);
     //自然常数
     System.out.println(Math.E);

 }
}

通过对象调用

创建对象：类名 对象名 = new 类名();

 //创建一个Random类的对象rd
  Random rd = new Random();
  //生成[0,10)范围内的随机数
  int num = rd.nextInt(10);

在同一个类中，方法A调用方法B

public class FunctionTest {
   
  public void a(){
   

   }

   public void b(){
   
       //调用本类中的另一个方法
       a();
   }
}

自定义方法

自定义方法要写在类中。

修饰符  返回值类型  方法名(参数类型 参数名,参数类型 参数名...){
   
       方法体
   }

• 返回值类型、方法名和参数列表(小括号中的内容)是组成方法的三要素
• 返回值类型可以是任意数据类型(原始类型/引用类型)
• 小括号中的内容称为参数列表只需写参数类型和参数名，多个参数用逗号隔开。可以没有参数，但必须要有小括号
• 访问修饰符可以不写，会有默认的修饰符
• 不同的返回值类型，要在方法体中返回(return)对应类型的结果，如果没有返回值，用void

方法的分类

• 无参数无返回值

  //打印100句hello world
    void printHello(){
        for(int i=0;i<100;i++){
            System.out.println("hello world");
        }
    }
  

• 有参数无返回值

//打印参数
void sayHello(String name){
   
    System.out.println("hello"+name);
}

• 无参数有返回值

//返回年份
int getYear(){
   
    return 2022; 
}

• 有参数有返回值

//根据出生年份，计算年龄
int getAge(int birth){
   
    return 2022-birth;
}

总结

• 无返回值的方法，返回值部分要写成void
• 有返回值的方法，方法体中必须要写上return，且要在return后写上对应返回值类型的数据
• 没有返回值的方法体中，也可以使用return关键字，但后面不能有值。只要出现return关键字，就不再执行后续代码
• 有返回值的方法在调用时，需要接收返回的数据才能使用该数据
• 方法定义时的参数称为形式参数，简称为形参，方便在方法体中使用。方法调用时传递的值称为实际参数，简称为实参，只需要保证满足形参的数据类型即可，与形参名无关

两种编程思想

面向过程编程

Procedure Oriented Programming 简称POP

是一种基本的编程思想，是将一件事按流程逐步实现。

这种思想强调事情完成的过程，分析步骤写出相应的代码。

如猜数游戏，每一个步骤都是能按顺序用代码描述出来，逻辑清晰。

但如果逻辑复杂，如xxx管理系统，则无法使用POP的思想实现。

C语言就是一门标志性的面向过程编程语言。

Java基础部分写的所有代码，都是面向过程的，都是一步步按流程执行。

面向对象编程

Object Oriented Programming 简称OOP

是当主流的编程思想，是创建解决问题的对象，赋予对象对应的行为和特征，让这些对象互相配合(调用
对象的方法)完成。

这种思想致力于将计算机中的世界，描述的和现实中一致的思想。

不同思想处理同一个问题

​

面向过程编程和面向对象编程的区别

面向过程

优点： 性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、Linux/Unix 等一般采用面向过程开发，性能是最重要的因素。
缺点： 没有面向对象易维护、易复用、易扩展

面向对象

优点： 易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护
缺点： 性能比面向过程低

总结

面向过程：亲力亲为，侧重于分析完成事情的过程。
面向对象：所有事情交给相应的对象完成，侧重于如何创建解决问题的对象。

类和对象

类Class

具有相同属性和行为的对象的集合，称为"一类"。可以理解为模板。

属性：描述对象的特征，在程序中，通过定义变量的形式表现属性。

行为：描述对象的动作，在程序中，通过定义方法的形式表现行为。

在程序中，通过定义一个class来定义一个类。在类中定义变量描述属性，定义方法描述行为。

定义类

[修饰符] class 类名{

//属性(变量)

//行为(方法)

}

/*
 * 定义一个类(模板)--Car小轿车类
 * 属性：变量
 * 	品牌
 * 	颜色
 * 	。。。
 * 行为：方法
 * 	行驶
 * 	停止
 * 	娱乐
 * 	飞行
 * 	。。。
 *
 * */

 public class Car {
   
   //定义属性
   String brand;//品牌
   String color;//颜色
   int seat=5;//座位数
   
   //定义行为
   void go(){
   
       System.out.println("在行驶");
   }

   void stop(){
   
       System.out.println("停下来了");
   }

   void fly(){
   
       System.out.println("飞起来了");
   }
} 

对象Object

对象是类的一个实例，是类的具体表现。

创建对象

类名 对象名 = new 构造方法([参数])；

创建的对象，通过"."操作符访问类中的非私有属性和方法。

类和对象的关系

对象是类的具体表现，类是对象的集合(模板)。

先定义类，才能通过该类创建对象。

成员变量和局部变量

成员变量

定义在类中的变量，称为成员变量，拥有默认值

数据类型	默认值
整型	0
浮点型	0.0
布尔型	false
字符型	空字符
引用类型(数组、类、接口)	null

public class Car{
   
      String name;//这就是一个成员变量，默认值为null
 void info(){
   
      //这里name虽然没有赋值，但是它是一个成员变量，属于引用类型，默认值为null
      System.out.println("车的名字："+name);//如果不赋值，最终打印"车名：null"
  }
}

局部变量

定义在方法中的变量，称为局部变量。默认有默认值，赋值后才能使用

   public class Test{
   
       public static void main(String[] args){
   
           //这里的num和name就是一个局部变量,没有默认值
           int num;
           System.out.println(num);//这里无法通过编译，因为num没有赋值
           String name="小吴";
           System.out.println(name);//这样才能正常输出
       }
  }

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

1、在类中的位置不同

成员变量：在类中方法外面

局部变量：在方法或者代码块中，或者方法的声明上（即在参数列表中）

2、在内存中的位置不同

成员变量：在堆中（方法区中的静态区）

局部变量：在栈中

3、生命周期不同

成员变量：随着对象的创建而存在，随着对象的消失而消失

局部变量：随着方法的调用或者代码块的执行而存在，随着方法的调用完毕或者代码块的执行完毕而消失

4、初始值

成员变量：有默认初始值

局部变量：没有默认初始值，使用之前需要赋值

构造方法

概念

构造方法是一个特殊的方法，没有返回值，方法名和类名一致。

每个类在定义时，都有一个默认隐藏的无参数的构造方法，在创建对象时调用。

构造方法通常用于初始化成员变量。

public class Test{
   
     //这就是无参数的构造方法，默认就会存在，不过是隐藏的
     public Test(){
   
         
     }
 }

特点

• 构造方法没有返回值(没有返回值这一部分，不是void)，构造方法名必须和类名相同
• 每个类默认有一个隐藏无参数的构造方法，方法体中没有内容，用于创建无参数的对象
• 如果自己写了有参数的构造方法，默认无参数的构造方法就会失效。如果想要同时拥有带参数和不带参数的构造方法，就需要把它们都写出来
• 构造方法可以限制创建对象时的参数
• 构造方法不能通过“.”操作符访问，只能通过new关键字创建对象时自动调用，所以构造方法通常用于初始化成员变量

面向对象的三大特性–封装

封装

使用private关键字对属性进行修饰。再对外提供一组公开的get/set方法用于对该属性读取或赋值。

可以防止除自身类之外的地方对该属性就行访问。

这样做可以保护关键属性，隐藏类内部的实现细节，

步骤

• 创建类，编写成员变量，给成员变量添加private修饰符

  public class Student{
           
      private int Id;    
      private String name;    
      private String major;
  }