2021-07-30 java 函数、数组、类和对象、构造方法、全局和局部变量

java 类和对象、函数、构造方法、全局和局部变量、数组。

约定大于配置

1、Java中的类和对象

1.1 编程思想

	代码编程中编程思想主要有：
	面向过程（C++、等）
	面向对象：java等

1.2 Java类

1.2.1 Java的是典型的面向对象编程：万物皆对象（详细问度娘）

• 类：是一切相似事物的统称。是一个泛泛的概念，可以用来描述相似事物的特征和行为。
• 对象：是一个具体的实体，是类的实现
• 特征：一类事物的共有属性（比如：无论黑黄白人都有年龄，身高、名字等属性）
• 行为：一类事物都能做出的动作（用行为来统称）（比如：人 睡觉，吃饭，深夜看手机嘿嘿傻笑等）

注：当存在人这个个体时，才会有人睡觉这个行为（有水才能喝水），所以要先有人才有人的某些属性和行为

为区别于现实，在编程中
特征叫：“属性”或者“变量”等
行为叫：“方法”等
~~ 牛头James A. Gosling说的，咱也不敢问，也不敢反驳~~

1.2.2 类的声明：

日常使用格式：
修饰符 class（这是个关键字必须要）类名{
对当前类属性的描述（变量）；
对当前类行为的描述（方法）；
}

package com.wang.haifeiyun;

public class Demo01 {
    public int a;
    public void a(){
        System.out.println("this is a method name a");
    }
}

完整（能带的都带上,即使用不上）格式：
修饰符 状态（很多时候不写）class（这是个关键字必须要）类名{
对当前类属性的描述（变量）；
对当前类行为的描述（方法）；
}

package com.wang.haifeiyun;

public static class Demo01 {
    public int a;
    public void a(){
        System.out.println("this is a method name a");
    }
}

1.2.3 创建对象（可以阅读：程序设计的六大原则）

原因：类是一类事物的形象描述，所以类只是一种描述，本质上不代表任何事物。
例如 （马路上有盲人突然对着天叫了一声“你站住”，没人知道他到底叫谁站住）

代码中对象的创建就是将类精确到一个确定的实体。
代码中，对象只做一些专门的事情，这个实体的能力是由界限的

格式：使用关键字new

	类名 对象名 = new 类名（）；
	~~ 留意为什么要在类名后面加上小括号 ~~

适用范围：
一般只在主方法“main”里面调用new 堆类进行实例化；

	类中可以定义 变量、方法、类
	类中可以调用 变量、方法、类

1.2.4 类和对象内存分析图：

jvm即 java虚拟机 需要占用咱们电脑的内存

内存分区：

			栈区 堆区 数据区 方法区 回收区

类对象的内存分析图：

~~ 细节可以进行百度搜索 ~~

2、方法【函数】

1.1、函数

原因：在代码开发中会遇到很多重复的操作或者功能，循环的使用范围有限，方法（函数）即对重复操作的整合，以此来减少：代码臃肿、阅读性差、维护性极差等特点

方法格式：

修饰符  返回值类型  方法名 （参数）{
方法体
}

其中：

• 范围修饰符：public、private、protect、default ；
• 状态修饰符：static、final、abstract（通常状态在范围之后）；
• 返回值类型：String等八大数据类型、或者引用类型、void无返回值
• 参数：String等八大数据类型、或者引用类型
  

方法主要分为有：

		有参无返回值、无参有返回值、有参有返回值、无参无返回值

    public int a;
   //有参无返回值、
    public void hai(int a){
        System.out.println("this is a method name hai"+a);
    }
    //无参无返回值
    public void hai(){
        System.out.println("this is a method name hai"+a);
    }
    //   有参有返回值、
    public int fei(int a){
        System.out.println("this is a method name fei"+a);
        return a;
    }
    //无参有返回值、
    public  int yun(){
        int a = 0;
        System.out.println("this is a method name yun"+a);
        return a;
    }

每个类只有一个主函数：

		public  static  void main(String[] args){…………}

注：main方法是java内置的方法，主函数，即程序的主入口
方法名：方法理论上和成员变量等价，所以方法名也使用小驼峰命名

    public void kunFeiYun(){
        System.out.println("this is a method name kunFeiYun");
    }

参数：形参（形式参数，用来预占一个位置）
实参: 实际参数 (实际运行和计算时使用）
返回值：对于有返回值的方法要使用return来返回结果，return只能返回一个结果参数，且在语法上等同于break,即会结束程序。

	在方法中可以定义：变量、类
	方法中可以调用  ：变量、方法、类

~~ 关于具体使用，还要看调用时目标时怎样的属性和状态。~~

2、数组

2.1 什么是数组

	数组:用来存储大量相同类型的数据

1. 一维数组在定义时（已经完成内存加载并准备使用）一定要写明数组的长度，且理论上数组一旦定义无法更改，存在一些渠道但是逻辑上并不是直接对原数组进行更改。
2. 数组的索引从0开始，Java在基本设计中没有反向索引（这里特指与python对比且不使用后期封装的其他方法的条件下） 数组常用于循环中

2.2 数组的定义：

正规格式：

1. 数组类型[] 数组名 = {值1，值2，…………}； 
   

2. 数组类型[] 数组名 =new 数据类型[] {值1，值2，…………}；
   

3. 数组类型[]  数组名 =  new 数组类型[长度]；
   

4. 网上我还差到有这种：

   数组类型[] 数组名 ； //先定义  ，此时未占用堆内存
    数组名 = new 数组类型[长度]；
   

    int[] arrs = {1, 23, 4, 12};
    int[] arrs04 = new int[]{1,3,442,4214};
    int[] arrs03 = new int[9];
    
第四种我这里报错
    int[] arrs02;
    arrs06 = new int[6];

数组还有很多自己的方法提供使用，Java库中有很多可以阅读javaApi手册

数组多与循环使用如：
经典冒泡排序：

public class Kun{

　　public static void main(String[] args) {

　　int[] arr = new int[]{-12,3,2,34,5,8,1};
　　//冒泡排序
　　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;
　　　　　　}
　　　　}
　　}
　　//遍历
　　for (int i = 0; i < arr.length; i++) {
　　　　System.out.println(arr[i]+"\t");
　　}
　　}
}

扩：三目运算符
基本格式：

		表达式？ 变量1（true时执行）：变量2（false时执行）
		z = x>y ? x-y : x+y;
		代码长的话可以使用括号

	注：可以理解为简化的if条件句

break和continue的关键字

	break：打断，破环，终止
	代码中的意义：结束程序运行
	Continue：继续
	代码中的意义：结束continue所在的那个最近的循环，结果为推出本次循环进入外层下一次循环或者跳出所在{}的程序

3 构造方法

构造方法用来初始化当前类实例对象（对当前类的成员属性进行赋值，所以构造方法决定了实例化对象的形式）

基本格式：（此为无参构造）

public class Demo01 {
    public Demo01() {
        System.out.println("constructor method");
    }
}

3.1、构造方法特点：

• 1、构造方法名和类名同名
• 2、不写状态修饰符且
• 3、没有返回值类型，
• 4、一般使用public修饰，也可以使用别的（但是会出现相应的问题，会的人可以随便使用）
• 5、构造方法可以写很多，但要遵守前三项，唯一区别是传入参数必须不同（不同参数类型和同类型参数数量不同），根据需要改变。
• 6、实例化类时构造方法自动加载（代码会根据传入的参数对所有的构造方法进行匹配，找的合适的进行调用）例如：A a = new A(4):创建类A的实例化对象时，加载了都在方法 public A（int a）{方法体}
• 7、构造方法可以相互调用， 本类中调用使用this关键字，形如this（参数） 调用时，放在调用函数第一行 构造函数不能自己调用自己， 一个调用构造函数中只能调用一个被调用构造函数，即只有一个this（参数）生效； 在继承中调用构造方法使用super，基本上和this的原则一样
• 8、子类同时调用父类和自己的构造方法时，放在第一位的生效，其他报错。
• 9、人为不写构造方法时，java会送一个无参构造方法，但是一般开发者编辑了任何一个构造函数，那么这个送的无参构造函数就会消失；（无参构造函数作用：防止空参继承报错）

构造方法可以无参，有参有一个参，有两个参………………

public class Demo01 {
    int Demo01(int a) {
        System.out.println("constructor method");
        return a;
    }

    public Demo01(String a) {
        System.out.println("constructor method");
    }

    public String Demo01() {
        String a = "a";
        System.out.println("constructor method");
        return a;

    }

}

3.2 构造代码块

位置：置于成员变量之后，构造方法之前
基本格式：

Class A{
public int a;//成员变量
{
构造代码块
}
Public A(){}//无参构造方法

构造代码和方法块位置解释：

Java要求先编译，再运行。
构造方法也是方法，也具有方法的很多特性，所以构造方法也可以对类中的参数进行操作，参数需要先定义后使用；
构造代码块也可以对变量进行操作。但是在加载时，构造代码块先于构造函数，也就是代码块跑起来了，但是方法还未定义

3.3 构造函数实例：

    public static void main(String[] args) {
        Kun kun = new Kun(4);
        Kun kun1 = new Kun();
        Kun kun2 = new Kun(1.2);
    }
}
class  Kun{
    int c = 3;
    {
        System.out.println("static constructor has a c : "+c);
    }
    Kun(int a) {
        System.out.println("constructor method   "+a);
    }

    public Kun(double a) {
        System.out.println("constructor method");
    }

    public  Kun() {
        int a = 0;
        System.out.println("constructor method");
    }

static constraction has a c : 3
constraction method   4
static constraction has a c : 3
constraction method
static constraction has a c : 3
constraction method

4、局部变量

Java中范围的界限是{………………}，
"{"是范围的开始，"}"是范围的结束。

变量的适用范围主要看他所处的大括号，变量在不借助别的方法等的条件下是不能超出自己的大括号使用的。在类的大括号中存在的大括号就是一个新的小的局部（可以联想到俄罗斯套娃，使劲儿套）

每个都是自己的小空间
结果就是{{{{{ ………………}}}}}}}

class Fei{
    public static void main(String[] args) {
        if (true){
            for (int i = 0; i <3 ; i++) {
                if(true){
                    for (int j = 0; j <i ; j++) {
                        
                    }
                }
                
            }
        }
    }
}

内部就是小局部
所以就有了，成员变量（类的）和局部变量（法的）

区别 成员变量 局部变量
定义的位置 定义在类的大括号的后面 定义在方法体内
作用 描述当前类的属性的 保存局部的数据的
初始值 不手动则是对应数据类型初始化的"0"值 必须赋值。没有赋值就不能用
所处内存空间 堆里面 栈里面
作用域 类内都可以使用 声明的方法中使用

结言。¹

---

1. 希望有错误多多指出，有不足多多提点，我有新的想法也会更新
   ↩︎