关于后端:这篇建议java开发都看看对Java方法及加深理解的很深值得一看

办法的定义

修饰符
返回类型
break：跳出 switch, 完结循环和 return 的区别
办法名：留神标准见名知意
参数列表（参数类型，参数名）…
异样抛出

// Demo01  类
public class Demo01 {

    // main 办法
    public static void main(String[] args) { }

    /*
    修饰符 返回值类型 办法名（……）{
        // 办法体
        return 返回值；}
    */
    // return 完结办法，返回一个后果！public String sayHello(){return "hello,world";}
    public void print(){return;}
    public int max(int a,int b){return a>b ? a : b; // 三元运算符}
 }

办法的调用

静态方法
非静态方法
形参和实参
值传递和援用传递
this 关键字

package com.opp.demo01
public class Demo2 {public static void main(String[] args){
        // 静态方法
    Student.say();

    // 非静态方法
    // 实例化这个类 new
    // 对象类型 对象名 = 对象值；Student student = new Student();
    student.say();}

    // 和类一起加载的
    public static void a(){b();// 报错
    }
    // 类实例化 之后才存在
    public void b(){}
}

//==================================
package com.oop.demo01;
// 学生类
public class Student{

    // 静态方法
    public static void say(){System.out.println("学生谈话了");
    }

    // 非静态方法
    public void say2(){System.out.println("学生谈话了");
    }
}

// 形参和实参
public static boid main(String[] args){
    // 理论参数和理论参数的类型要对应
    int add = Demo03.add(1,2);
    System.out.println(add);
}
public static int add(int a,int b){return a+b;}

// 值传递
public class Demo04{public static void main(String[] args){
        int a = 1;
        System.out.println(a);// 1

        Demo04.change(a);
        System.out.println(a);// 1
    }

    // 返回值为空
    public static void change(int a){a = 10;}
}

// 援用传递：对象，实质还是值传递
public class Demo05{public static void main(String[] args){Person person = new Person();
        System.out.println(person.name);//  null

        Demo05.change(person);
        System.out.println(person.name);// 里
    }
    public static void change(Person person){// person 是一个对象：指向的 ---》Person person = new Person(); 这是一个具体的人，能够扭转属性！person.name = "里";
    }
}

// 定义了一个 Person 类，有一个属性：name
class Person{String name;}

类是一种形象的数据类型，它是对某一类事物整体形容 / 定义，然而并不能代表某一个具体的事物。
- 动物、动物、手机、电脑……
- Person 类、Pet 类、Car 类等，这些类都是用来形容 / 定义某已类具体的事物应该具备的特点和行为
对象是抽象概念的具体实例
- 张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例。
- 可能体现出特点，展现出性能的是具体的实例，而不是一个形象的概念。

应用 new 关键字创建对象
应用 new 关键字创立的时候，除了分配内存空间之外，还会给创立好的对象进行默认的初始化以及对类中结构器的调用。
类中的结构器也成为构造方法，是在进行创建对象的时候必须要调用的。并且结构器有以下两个特点：
- 1、必须和类的名字雷同
- 2、必须没有返回值类型，也不能写 void
结构器必须要把握
代码实例（类与对象的创立）：

public static void main(String[] args) {
    // 类：形象的，实例化
    // 类实例化后会返回一个本人的对象！// student 对象就是一个 Student 类的具体实例！Student xiaoming = new Student();
    Student xh = new Student();

    xiaoming.name = "小明";
    xiaoming.age = 3;

    System.out.println(xiaoming.name);
    System.out.println(xiaoming.age);

    xh.name = "小红";
    xh.age = 3;

    System.out.println(xh.name);
    System.out.println(xh.age);
}

// 学生类
public class Student{
    // 属性：字段
    String name;// null
    int age;// 0

    // 办法
    public void study(){System.out.println(this.name+"在学习");
    }
}

代码实例（结构器详解）：

public static void main(String[] args) {
    //new 实例化了一个对象
    Person person = new Person();

    System.out.println(person.name); // LiBo
}

// java ---> class
public class Person {
    // 一个类即便什么都不写，它也会存在一个办法
    // 显示定义结构器

    String name;

    // 实例化初始值
    // 1、应用 new 关键字，实质实战调用结构器
    public Person() {this.name = "LiBo"}

    // 有参结构：一旦定义了有参结构，无餐就必须显示定义
    public Person(String name){this.name = name;}

    //alt + insert 快捷创立结构器
}

总结
结构器：1、和类名雷同 2、没有返回值
作用：
1、new 实质在调用构造方法
2、初始化对象的值
留神点：
1、定义有参结构之后，如果想应用无参结构，显示的定义一个无参结构

类与对象
- 类是一个模板：形象，对象是一个具体的实列
办法
- 定义、调用！
对应的援用
- 援用类型、根本类型（8）
- 对象是通过援用来操作的：栈 —-> 堆
属性：字段 Field 成员变量
- 默认初始化：
  - 数字：0 0.0
  - char：u0000
  - boolean：false
  - 援用：null
- 修饰符属性类型属性名 = 属性值；
对象的创立和应用
- 必须应用 new 关键字创建对象，结构器 Person muzi = new Person();
- 对象的属性 muzi.name
- 对象的办法 muzi.sleep();
类
- 动态的属性属性
- 动静的行为办法

最初提供收费的 Java 架构学习材料，学习技术内容蕴含有：Spring，Dubbo，MyBatis, RPC, 源码剖析，高并发、高性能、分布式, 性能优化，微服务高级架构开发等等。关注我的公众号前程有光即可获取！

关于后端:这篇建议java开发都看看对Java方法及加深理解的很深值得一看

办法和加深

类与对象的关系

创立与初始化对象

简略小结类与对象

最初