1.打开冰箱
2.把大象装进冰箱
3.把冰箱门关住

//分为三个类
人{
   打开（冰箱）{
   冰箱.开门();  
   }
   操作(大象){
       大象.进入(冰箱);
   }
   关闭(冰箱){  
      冰箱.关门();   
   }
 }

冰箱{
   开门(){ } 
   关门(){ }
 }

大象{
   进入(冰箱){ 
   }
 }

类的定义使用关键字：class。格式如下：

[修饰符] class 类名{
   属性声明;
   方法声明;
 }

举例1：
public class Person{
   *//**声明属性age*
   int age ;           

   *//**声明方法showAge()*
   public void eat() {    
     System.out.println("人吃饭");
   }
 }

举例2：

public class Dog{
   *//**声明属性*
   String type; *//**种类*
   String nickName; *//**昵称*
   String hostName; *//**主人名称*

   *//**声明方法*
   public void eat(){ *//**吃东西*
    System.out.println("狗狗进食");   
   }
 }

public class Person{
   String name;
   char gender;
   Dog dog;

   *//**喂宠物*
   public void feed(){
     dog.eat();
   }
 }

方式1：给创建的对象命名*
 把创建的对象用一个引用数据类型的变量保存起来，这样就可以反复使用这个对象了*
 类名 对象名 = new 类名();

方式2：
 new 类名()*//**也称为匿名对象

class PersonTest{
   public static void main(String[] args){
    *//**创建Person**类的对象*
    Person per = new Person();
    *//**创建Dog**类的对象*
    Dog dog = new Dog();
   }
 }

//**声明Animal**类*
 public class Animal { *//**动物类*
   public int legs;

   public void eat() {
     System.out.println("Eating.");
   }

   public void move() {
     System.out.println("Move.");
   }
 }

//声明测试类
 public class AnimalTest {
   public static void main(String args[]) {
     *//**创建对象*
     Animal xb = new Animal();
     xb.legs = 4;*//**访问属性*
     System.out.println(xb.legs);
     xb.eat();*//**访问方法*
     xb.move();*//**访问方法*
   }
 }

public class Game{
   public static void main(String[] args){
     Person p = new Person();
     *//**通过Person**对象调用属性*
     p.name = "康师傅";
     p.gender = '男';
     p.dog = new Dog(); *//**给Person**对象的dog**属性赋值*
      *//**给Person**对象的dog**属性的type**、nickname**属性赋值*
     p.dog.type = "柯基犬";
     p.dog.nickName = "小白";

     *//**通过Person**对象调用方法*
     p.feed();
  }
 }

class Person { *//**类：人*
   String name;
   int age;
   boolean isMale;
 }

 public class PersonTest { *//**测试类*
   public static void main(String[] args) {
     Person p1 = new Person();
     p1.name = "赵同学";
     p1.age = 20;
     p1.isMale = true;

     Person p2 = new Person();
     p2.age = 10;
     
     Person p3 = p1;
     p3.name = "郭同学";

   }
 }

public class StudentTest{
   public static void main(String[] args){
     System.out.println(new Student());*//Student@7852e922*

     Student stu = new Student();
     System.out.println(stu);*//Student@4e25154f*
     
     int[] arr = new int[5];
    System.out.println(arr);*//[I@70dea4e*

   }
 }

class Car {
   String color = "red";
   int num = 4;

   void show() {
     System.out.println("color=" + color + ",num=" + num);
   }
 }

 class CarTest {
   public static void main(String[] args) {
     Car c1 = new Car();  *//**建立对象c1*
     Car c2 = new Car();  *//**建立对象c2*
     c1.color = "blue";  *//**对对象的属性进行修改*
     c1.show();  *//**使用对象的方法*
     c2.show();
   }
 }

[修饰符1] class 类名{
   [修饰符2] 数据类型 成员变量名 [= 初始化值]; 
 }

public class Person{
   private int age;       *//**声明private**变量 age*
   public String name = “Lila”;  *//**声明public**变量 name*
 }

class Person {*//**人类*
   *//1.**属性*
   String name;*//**姓名*
   int age = 1;*//**年龄*
   boolean isMale;*//**是否是男性*

   public void show(String nation) {
     *//nation:**局部变量*
     String color;*//color:**局部变量*
     color = "yellow";
   }
 }

 *//**测试类*
 class PersonTest {
   public static void main(String[] args) {
     Person p = new Person();
     p.show("CHN");
   }
 }

–     Math.random()的random()方法

–     Math.sqrt(x)的sqrt(x)方法

–     System.out.println(x)的println(x)方法

–     new Scanner(System.in).nextInt()的nextInt()方法

–     Arrays类中的binarySearch()方法、sort()方法、equals()方法

  public class Person{
  private int age;
  public int getAge() { *//**声明方法getAge()*
  return age; 
  }
  public void setAge(int i) { *//**声明方法setAge*
  age = i;    *//**将参数i**的值赋给类的成员变量age*
  }
}

1****、声明方法的语法格式**

[修饰符] 返回值类型 方法名([形参列表])[throws 异常列表]{
     方法体的功能代码
 }

（1）一个完整的方法 = 方法头 + 方法体。

方法头就是[修饰符] 返回值类型 方法名([形参列表])[throws 异常列表]，也称为方法签名。通常调用方法时只需要关注方法头就可以，从方法头可以看出这个方法的功能和调用格式。

方法体就是方法被调用后要执行的代码。对于调用者来说，不了解方法体如何实现的，并不影响方法的使用。

**（2）方法头可能包含5个部分**

**修饰符**：可选的。方法的修饰符也有很多，例如：public、protected、private、static、abstract、native、final、synchronized等，后面会一一学习。

–     其中，权限修饰符有public、protected、private。在讲封装性之前，我们先默认使用pulbic修饰方法。

–     其中，根据是否有static，可以将方法分为静态方法和非静态方法。其中静态方法又称为类方法，非静态方法又称为实例方法。咱们在讲static前先学习实例方法。

**返回值类型**： 表示方法运行的结果的数据类型，方法执行后将结果返回到调用者。

–     无返回值，则声明：void

–     有返回值，则声明出返回值类型（可以是任意类型）。与方法体中“return 返回值”搭配使用

**方法名**：属于标识符，命名时遵循标识符命名规则和规范，“见名知意”

**形参列表**：表示完成方法体功能时需要外部提供的数据列表。可以包含零个，一个或多个参数。

–     无论是否有参数，()不能省略

–     如果有参数，每一个参数都要指定数据类型和参数名，多个参数之间使用逗号分隔，例如：

•     一个参数： (数据类型 参数名)

•     二个参数： (数据类型1 参数1, 数据类型2 参数2) 

–     参数的类型可以是基本数据类型、引用数据类型

**throws 异常列表**：可选，在【第09章-异常处理】章节再讲

**（3）方法体**：方法体必须有{}括起来，在{}中编写完成方法功能的代码

**（4）关于方法体中return语句的说明：**

return语句的作用是结束方法的执行，并将方法的结果返回去

如果返回值类型不是void，方法体中必须保证一定有 return 返回值; 语句，并且要求该返回值结果的类型与声明的返回值类型一致或兼容。

如果返回值类型为void时，方法体中可以没有return语句，如果要用return语句提前结束方法的执行，那么return后面不能跟返回值，直接写return ; 就可以。

return语句后面就不能再写其他代码了，否则会报错：Unreachable code

补充：方法的分类：按照是否有形参及返回值

package com.atguigu.test04.method;

 */***
 *** *方法定义案例演示*
 **/*
 public class MethodDefineDemo {
   */***
   *** *无参无返回值方法的演示*
   **/*
   public void sayHello(){
     System.out.println("hello");
   }

   */***
   *** *有参无返回值方法的演示*
   ** @*param length int *第一个参数，表示矩形的长*
   *** *@*param width int *第二个参数，表示矩形的宽*
   *** *@*param sign char *第三个参数，表示填充矩形图形的符号*
   **/*
   public void printRectangle(int length, int width, char sign){
     for (int i = 1; i <= length ; i++) {
       for(int j=1; j <= width; j++){
         System.out.print(sign);
       }
       System.out.println();
     }
   }

   */***
   *** *无参有返回值方法的演示*
   ** @*return
   **/*
   public int getIntBetweenOneToHundred(){
     return (int)(Math.random()*100+1);
   }

   */***
   *** *有参有返回值方法的演示*
   ** @*param a int *第一个参数，要比较大小的整数之一*
   *** *@*param b int *第二个参数，要比较大小的整数之二*
   *** *@*return int *比较大小的两个整数中较大者的值*
   **/*
   public int max(int a, int b){
     return a > b ? a : b;
   }
 }

对象.方法名([实参列表])

举例1：

package com.atguigu.test04.method;

 */***
 *** *方法调用案例演示*
 **/*
 public class MethodInvokeDemo {
   public static void main(String[] args) {
     *//**创建对象*
     MethodDefineDemo md = new MethodDefineDemo();

     System.out.println("-----------------------方法调用演示-------------------------");
     
     *//**调用MethodDefineDemo**类中无参无返回值的方法sayHello*
     md.sayHello();
     md.sayHello();
     md.sayHello();
     *//**调用一次，执行一次，不调用不执行*
     
     System.out.println("------------------------------------------------");
     *//**调用MethodDefineDemo**类中有参无返回值的方法printRectangle*
     md.printRectangle(5,10,'@');
     
     System.out.println("------------------------------------------------");
     *//**调用MethodDefineDemo**类中无参有返回值的方法getIntBetweenOneToHundred*
     md.getIntBetweenOneToHundred();*//**语法没问题，就是结果丢失*
     
     int num = md.getIntBetweenOneToHundred();
     System.out.println("num = " + num);
     
     System.out.println(md.getIntBetweenOneToHundred());
     *//**上面的代码调用了getIntBetweenOneToHundred**三次，这个方法执行了三次*
     
     System.out.println("------------------------------------------------");
     *//**调用MethodDefineDemo**类中有参有返回值的方法max*
     md.max(3,6);*//**语法没问题，就是结果丢失*
     
     int bigger = md.max(5,6);
     System.out.println("bigger = " + bigger);
     
     System.out.println("8,3中较大者是：" + md.max(8,9));

   }
 }

举例2：

*//1**、创建Scanner**的对象*
 Scanner input = new Scanner(System.in);*//System.in**默认代表键盘输入*

 *//2**、提示输入xx*
 System.out.print("请输入一个整数："); *//**对象.**非静态方法(**实参列表)*

 *//3**、接收输入内容*
 int num = input.nextInt(); *//**对象.**非静态方法()

类{
   方法1(){
     
   }
   方法2(){
     
   }
 }

类{
   方法1(){
     方法2(){ *//**位置错误*
     

    }

   }
 }

public class Person {
   public static void main(String[] args) {
     Person p1 = new Person();
     p1.eat();

   }
   public static void eat() {
     sleep();
     System.out.println("人：吃饭");
   }
   public static void sleep(){
     System.out.println("人：睡觉");
     doSport();
   }
   public static void doSport(){
     System.out.println("人：运动");
   }
 }

public class User {
   String name;
   String password;*//**密码*

   */***
   *** *实现用户登录的判断*

***

   ** @*param inputName *输入的用户名*
   *** *@*param inputPwd *输入的密码*
   **/*
   public void login(String inputName,String inputPwd){
     if(name.equals(inputName) && password.equals(inputPwd)){
       System.out.println("登录成功：欢迎你，" + name);
     }else{
       System.out.println("登录失败：用户名或密码错误！");
     }
   }

   */***
   *** *实现用户登录的判断*
   ** @*param inputName *输入的用户名*
   *** *@*param inputPwd *输入的密码*
   *** *@*return true*:**登录成功* false*:**登录失败*
   **/*
   public boolean login1(String inputName,String inputPwd){
 *//    if(name.equals(inputName) && password.equals(inputPwd)){*
 *//      return true;*
 *//    }else{*
 *//      return false;*
 *//    }*

     *//**简化为：*
     return name.equals(inputName) && password.equals(inputPwd);

   }

 }

 *** *用户界面类*UserInterface*：*

***

 *** *-* *在用户界面类中添加*main*方法，接受用户输入，并调用用户类的登录方法进行验证。*
 *** *-* *输出：*
 ***   *-* *登录失败：用户名或密码错误！*
 ***   *-* *登录成功：欢迎你，用户名！*
 **/*
 public class UserInterface {
   public static void main(String[] args) {

     User u1 = new User();
     u1.name = "Tom";
     u1.password = "abc123";
     Scanner scanner = new Scanner(System.in);
     System.out.print("请输入用户名：");
     String name = scanner.next();
     System.out.print("请输入密码：");
     String pwd = scanner.next();
     
     *//**演示1**：*

 *//    u1.login(name,pwd);*

     *//**演示2**：*
     boolean isLogin = u1.login1(name, pwd);
     if(isLogin){
       System.out.println("登录成功：欢迎你，" + u1.name);
     }else{
       System.out.println("登录失败：用户名或密码错误！");
     }
     
     scanner.close();

   }
 }

public class Student {

   int number;*//**学号*
   int state;*//**年级*
   int score;*//**成绩*


   public void info(){
    System.out.println("number : " + number 
        \+ ",state : " + state + ",score : " + score);
   }

 }

public class StudentTest {

   public static void main(String[] args) {

    *// Student s1 = new Student();*
    *// s1.number = 1;*
    *// s1.state = (int)(Math.random() \* 6 + 1);//[1,6]*
    *// s1.score = (int)(Math.random() \* 101);//[0,100]*
    *//*
    *// Student s2 = new Student();*
    *// s2.number = 2;*
    *// s2.state = (int)(Math.random() \* 6 + 1);//[1,6]*
    *// s2.score = (int)(Math.random() \* 101);//[0,100]*
    *//*
    *// //....*
    *//* *对象数组*
    *// String[] arr = new String[10];*
    *//* *数组的创建*
    Student[] students = new Student[20];
    *//* *通过循环结构给数组的属性赋值*
    for (int i = 0; i < students.length; i++) {
      *//* *数组元素的赋值*
      students[i] = new Student();
      *//* *数组元素是一个对象，给对象的各个属性赋值*
      students[i].number = (i + 1);
      students[i].state = (int) (Math.random() * 6 + 1);*// [1,6]*
      students[i].score = (int) (Math.random() * 101);*// [0,100]*
    }
     
    *//* *问题一：打印出3**年级(state**值为3**）的学生信息。*
    for (int i = 0; i < students.length; i++) {
     
      if (students[i].state == 3) {

 *//      System.out.println(*
 *//          "number:" + students[i].number + ",state:" + students[i].state + ",score:" + students[i].score);*
        students[i].info();
        

      }
     
     }
    System.out.println("******************************");
    *//* *问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息*
    *//* *排序前*
    for (int i = 0; i < students.length; i++) {

 *//     System.out.println(*
 *//        "number:" + students[i].number + ",state:" +* 
 *//            students[i].state + ",score:" + students[i].score);*
      

      students[i].info();
    }
     
    System.out.println();
    *//* *排序：*
    for (int i = 0; i < students.length - 1; i++) {
      for (int j = 0; j < students.length - 1 - i; j++) {
        if (students[j].score > students[j + 1].score) {
          Student temp = students[j];
          students[j] = students[j + 1];
          students[j + 1] = temp;
        }
      }
    }
     
    *//* *排序后：*
    for (int i = 0; i < students.length; i++) {

 *//     System.out.println(*
 *//        "number:" + students[i].number + ",state:" +* 
 *//            students[i].state + ",score:" + students[i].score);*
      students[i].info();
    }
   }
 }

package com.atguigu.test08.array;

 public class Rectangle {
   double length;
   double width;

   public double area(){*//**面积*
     return length * width;
   }

   public double perimeter(){*//**周长*
     return 2 * (length + width);
   }

   public String getInfo(){
     return "长：" + length +
         "，宽：" + width +
         "，面积：" + area() +
         "，周长：" + perimeter();
   }
 }

package com.atguigu.test08.array;

 public class ObjectArrayTest {
   public static void main(String[] args) {
     *//**声明并创建一个长度为3**的矩形对象数组*
     Rectangle[] array = new Rectangle[3];

     *//**创建3**个矩形对象，并为对象的实例变量赋值，*
     *//3**个矩形对象的长分别是10,20,30*
     *//3**个矩形对象的宽分别是5,15,25*
     *//**调用矩形对象的getInfo()**返回对象信息后输出*
     for (int i = 0; i < array.length; i++) {
       *//**创建矩形对象*
       array[i] = new Rectangle();
     
       *//**为矩形对象的成员变量赋值*
       array[i].length = (i+1) * 10;
       array[i].width = (2*i+1) * 5;
     
       *//**获取并输出对象对象的信息*
       System.out.println(array[i].getInfo());
     }

   }
 }

//System.out.println()**方法就是典型的重载方法，其内部的声明形式如下：*
 public class PrintStream {
   public void println(byte x)
   public void println(short x)
   public void println(int x)
   public void println(long x)
   public void println(float x)
   public void println(double x)
   public void println(char x)
   public void println(double x)
   public void println()

 }

 public class HelloWorld{
   public static void main(String[] args) {
     System.out.println(3);
     System.out.println(1.2f);
     System.out.println("hello!");
   }
 }

//**返回两个整数的和*
 public int add(int x,int y){
   return x+y;
 }

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

 举例3：方法的重载和返回值类型无关

public class MathTools {
   *//**以下方法不是重载，会报错*
   public int getOneToHundred(){
     return (int)(Math.random()*100);
   }

   public double getOneToHundred(){
     return Math.random()*100;
   }
 }

方法名(参数的类型名 ...参数名)

//JDK 5.0**以前：采用数组形参来定义方法，传入多个同一类型变量*
 public static void test(int a ,String[] books);

 *//JDK5.0**：采用可变个数形参来定义方法，传入多个同一类型变量*
 public static void test(int a ,String...books);

public class StringTools {
   String concat(char seperator, String... args){
     String str = "";
     for (int i = 0; i < args.length; i++) {
       if(i==0){
         str += args[i];
       }else{
         str += seperator + args[i];
       }
     }
     return str;
   }
 }

package com.atguigu.test05.param;

 public class StringToolsTest {
   public static void main(String[] args) {
     StringTools tools = new StringTools();

     System.out.println(tools.concat('-'));
     System.out.println(tools.concat('-',"hello"));
     System.out.println(tools.concat('-',"hello","world"));
     System.out.println(tools.concat('-',"hello","world","java"));

   }
 }

案例2：求n个整数的和

public class NumberTools {
   public int total(int[] nums){
     int sum = 0;
     for (int i = 0; i < nums.length; i++) {
       sum += nums[i];
     }
     return sum;
   }

   public int sum(int... nums){
     int sum = 0;
     for (int i = 0; i < nums.length; i++) {
       sum += nums[i];
     }
     return sum;
   }
 }

public class TestVarParam {
   public static void main(String[] args) {
     NumberTools tools = new NumberTools();

     System.out.println(tools.sum());*//0**个实参*
     System.out.println(tools.sum(5));*//1**个实参*
     System.out.println(tools.sum(5,6,2,4));*//4**个实参*
     System.out.println(tools.sum(new int[]{5,6,2,4}));*//**传入数组实参*
     
     System.out.println("------------------------------------");
     System.out.println(tools.total(new int[]{}));*//0**个元素的数组*
     System.out.println(tools.total(new int[]{5}));*//1**个元素的数组*
     System.out.println(tools.total(new int[]{5,6,2,4}));*//**传入数组实参*

   }
 }

public class MathTools {
   *//**求两个整数的最大值*
   public int max(int a,int b){
     return a>b?a:b;
   }

   *//**求两个小数的最大值*
   public double max(double a, double b){
     return a>b?a:b;
   }

   *//**求三个整数的最大值*
   public int max(int a, int b, int c){
     return max(max(a,b),c);
   }

   *//**求n**个整数的最大值*
   public int max(int... nums){
     int max = nums[0];*//**如果没有传入整数，或者传入null**，这句代码会报异常*
     for (int i = 1; i < nums.length; i++) {
       if(nums[i] > max){
         max = nums[i];
       }
     }
     return max;
   }
   */\*  //**求n**整数的最大值*
   *public int max(int[] nums){ //**编译就报错，与(int... nums)**无法区分*
     *int max = nums[0];//**如果没有传入整数，或者传入null**，这句代码会报异常*
     *for (int i = 1; i < nums.length; i++) {*
       *if(nums[i] > max){*
         *max = nums[i];*
       *}*
     *}*
     *return max;*
   *}\*/*

 */\*  //**求n**整数的最大值*
   *public int max(int first, int... nums){ //**当前类不报错，但是调用时会引起多个方法同时匹配*
     *int max = first;*
     *for (int i = 0; i < nums.length; i++) {*
       *if(nums[i] > max){*
         *max = nums[i];*
       *}*
     *}*
     *return max;*
   *}\*/*
 }

public class Test {
   public static void main(String[] args) {
    int m = 10;
    int n = 20;
    

    System.out.println("m = " + m + ", n = " + n);
    *//**交换m**和n**的值*

 *//   int temp = m;*
 *//   m = n;*
 *//   n = temp;*
    

    ValueTransferTest1 test = new ValueTransferTest1();
    test.swap(m, n);
    
    System.out.println("m = " + m + ", n = " + n);

   }

   public void swap(int m,int n){
    int temp = m;
    m = n;
    n = temp;
   }

 }

public class Test {
   public static void main(String[] args) {
    

    Data d1 = new Data();
    d1.m = 10;
    d1.n = 20;
    
    System.out.println("m = " + d1.m + ", n = " + d1.n);
    
    *//**实现* *换序*
    ValueTransferTest2 test = new ValueTransferTest2();
    test.swap(d1);  
    System.out.println("m = " + d1.m + ", n = " + d1.n);

   }
   public void swap(Data data){
    int temp = data.m;
    data.m = data.n;
    data.n = temp;
   }
 }

class Data{
   int m;
   int n;
 }

public class AssignNewObject {
   public void swap(MyData my){
     my = new MyData(); *//**考虑堆空间此新创建的对象，和main**中的data**对象是否有关*
     int temp = my.x;
     my.x = my.y;
     my.y = temp;

   }

   public static void main(String[] args) {
     AssignNewObject tools = new AssignNewObject();
     

     MyData data = new MyData();
     data.x = 1;
     data.y = 2;
     System.out.println("交换之前：x = " + data.x +",y = " + data.y);*//*
     tools.swap(data);*//**调用完之后，x**与y**的值交换？*
     System.out.println("交换之后：x = " + data.x +",y = " + data.y);*//*

   }
 }

 class MyData{
   int x ;
   int y;
 }

练习2：如下操作是否可以实现数组排序

public class ArrayTypeParam {

   *//**冒泡排序，实现数组从小到大排序*
   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]+" ");
     }
     System.out.println();
   }

   public static void main(String[] args) {
     ArrayTypeParam tools = new ArrayTypeParam();

     int[] nums = {4,3,1,6,7};
     System.out.println("排序之前：");
     tools.print(nums);
     
     tools.sort(nums);*//**对nums**数组进行排序*
     
     System.out.println("排序之后：");
     tools.print(nums);*//**输出nums**数组的元素*

   }
 }

练习3：通过内存结构图，写出如下程序的输出结果

*//**栈：每个方法在调用时，都会有以栈帧的方法压入栈中。栈帧中保存了当前方法中声明的变量：方法内声明的，形参*
 *//**堆：存放**new**出来的**"**东西**"**：对象（成员变量在对象中）、数组实体（数组元素）。* 
 *//**注意：变量前如果声明有类型，那么这就是一个新的刚要定义的变量。如果变量前没有声明类型，那就说明此变量在之前已经声明过。*
 public class TransferTest3 {
   public static void main(String args[]) {
     TransferTest3 test = new TransferTest3();
     test.first();
   }
   public void first() {
     int i = 5;
     Value v = new Value();
     v.i = 25;
     second(v, i);
     System.out.println(v.i);
   }
   public void second(Value v, int i) {
     i = 0;
     v.i = 20;
     Value val = new Value();
     v = val;
     System.out.println(v.i + " " + i);
   }
 }

 class Value {
   int i = 15;
 }

*//**法一：*
 public static void method(int a, int b) {
   *//* *在不改变原本题目的前提下，如何写这个函数才能在main**函数中输出a=100**，b=200**？* 
   a = a * 10;
   b = b * 20;
   System.out.println(a);
   System.out.println(b);
   System.exit(0);
 }

 *//**法二：*
 public static void method(int a, int b) {

   PrintStream ps = new PrintStream(System.out) {
     @Override
     public void println(String x) {
   
       if ("a=10".equals(x)) {
         x = "a=100";
       } else if ("b=10".equals(x)) {
         x = "b=200";
       }
       super.println(x);
     }
   };
   
   System.setOut(ps);

 }

 public void methodA(){
 	methodA();
 }

间接递归：可以理解为A()方法调用B()方法，B()方法调用C()方法，C()方法调用A()方法。

   public static void A(){
 B();
 }

 public static void B(){
 C();
 }

 public static void C(){
 A();
 }

举例1：计算1 ~ n的和

public class RecursionDemo {
   public static void main(String[] args) {
     RecursionDemo demo = new RecursionDemo();
    *//**计算1~num**的和，使用递归完成*
    int num = 5;
     *//* *调用求和的方法*
    int sum = demo.getSum(num);
     *//* *输出结果*
    System.out.println(sum);
    
   }
   */**
    *通过递归算法实现.*
    *参数列表:int* 
    *返回值类型: int* 
   **/*
   public int getSum(int num) {
     */** 
       *num**为1**时,**方法返回1,*
       *相当于是方法的出口,num**总有是1**的情况*
     **/*
    if(num == 1){
      return 1;
    }
     */**
      *num**不为1**时,**方法返回 num +(num-1)**的累和*
      *递归调用getSum**方法*
     **/*
    return num + getSum(num-1);
   }
 }

public int multiply(int num){
   if(num == 1){
    return 1;
   }else{
    return num * multiply(num - 1);
   }
 }

public int f(int num){
   if(num == 0){
    return 1;
   }else if(num == 1){
    return 4;
   }else{
    return 2 * f(num - 1) + f(num - 2);
   }
 }

public int func(int num){
   if(num == 20){
    return 1;
   }else if(num == 21){
    return 4;
   }else{
     return func(num + 2) - 2 * func(num + 1);
   }
 }

//**使用递归的写法*
   int f(int n) {*//**计算斐波那契数列第**n**个值是多少*
     if (n < 1) {*//**负数是返回特殊值**1**，表示不计算负数情况*
       return 1;
     }
     if (n == 1 || n == 2) {
       return 1;
     }
     return f(n - 2) + f(n - 1);
   }

   *//**不用递归*
   int fValue(int n) {*//**计算斐波那契数列第**n**个值是多少*
     if (n < 1) {*//**负数是返回特殊值**1**，表示不计算负数情况*
       return 1;
     }
     if (n == 1 || n == 2) {
       return 1;
     }
     *//**从第三个数开始，* *等于* *前两个整数相加*
     int beforeBefore = 1; *//**相当于**n=1**时的值*
     int before = 1;*//**相当于**n=2**时的值*
     int current = beforeBefore + before; *//**相当于**n=3**的值*
     *//**再完后*
     for (int i = 4; i <= n; i++) {
       beforeBefore = before;
       before = current;
       current = beforeBefore + before;
       */**
       *假设**i=4*
         *beforeBefore = before; //**相当于**n=2**时的值*
         *before = current; //**相当于**n=3**的值*
         *current = beforeBefore + before; //**相当于**n = 4**的值*
       *假设**i=5*
         *beforeBefore = before; //**相当于**n=3**的值*
         *before = current; //**相当于**n = 4**的值*
         *current = beforeBefore + before; //**相当于**n = 5**的值*
         *....*
       **/*
     }
     return current;
   }

private int count = 0;

  public int recursion(int k) {
    count++;
    System.out.println("count1:" + count + " k:" + k);
    if (k <= 0) {
      return 0;
    }
    return recursion(k - 1) + recursion(k - 2);*//287*
    *//return recursion(k - 1);//11*
    *//return recursion(k - 1) + recursion(k - 1);//2047*
  }

pack1\pack2\PackageTest.java

package pack1.pack2;  *//**指定类PackageTest**属于包pack1.pack2*

 public class PackageTest{
   public void display(){
    System.out.println("in method display()");
   }
 }

import 包名.类名;

import pack1.pack2.Test;  *//import pack1.pack2.\*;**表示引入pack1.pack2**包中的所有结构*

 public class PackTest{
   public static void main(String args[]){
    Test t = new Test();     *//Test**类在pack1.pack2**包中定义*
    t.display();
   }
 }

public class Person {
   private String name;
   private int age;
   private boolean marry;
 }

public class Person {
   private String name;
   private int age;
   private boolean marry;

   public void setName(String n) {
    name = n;
   }

   public String getName() {
     return name;
   }

   public void setAge(int a) {
     age = a;
   }

   public int getAge() {
     return age;
   }

   public void setMarry(boolean m){
     marry = m;
   }

   public boolean isMarry(){
     return marry;
   }
 }

public class PersonTest {
   public static void main(String[] args) {
     Person p = new Person();

     *//**实例变量私有化，跨类是无法直接使用的*
    */\* p.name = "**张三";*
     *p.age = 23;*
     *p.marry = true;\*/*
     
     p.setName("张三");
     System.out.println("p.name = " + p.getName());
     
     p.setAge(23);
     System.out.println("p.age = " + p.getAge());
     
     p.setMarry(true);
     System.out.println("p.marry = " + p.isMarry());

   }
 }

public class ArrayUtil {

    public int max(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 min(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 sum(int[] arr) {
    int sum = 0;
    for(int i = 0;i < arr.length;i++){
      sum += arr[i];
    }
    return sum;
   }


   public int avg(int[] arr) {
    int sumValue = sum(arr);
    return sumValue / arr.length;
   }

   *//* *创建一系列重载的上述方法*
   *// public double max(double[] arr){}*
   *// public float max(float[] arr){}*
   *// public byte max(byte[] arr){}*

    public void print(int[] arr) {
    for(int i = 0;i < arr.length;i++){
      System.out.print(arr[i] + " ");
    }
    System.out.println();

   }

    public int[] copy(int[] arr) {
    int[] arr1 = new int[arr.length];
    for(int i = 0;i < arr.length;i++){
      arr1[i] = arr[i];
    }
    return arr1;

   }

   public void reverse(int[] arr) {
    for(int i = 0,j = arr.length - 1;i < j;i++,j--){
      int temp = arr[i];
      arr[i] = arr[j];
      arr[j] = temp;
    }
   }

   public void sort(int[] arr,String desc) {
    

    if("ascend".equals(desc)){*//if(desc.equals("ascend")){*
      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;*
           swap(arr,j,j+1);
          }
        }
      }
    }else if ("descend".equals(desc)){
      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;*
           swap(arr,j,j+1);
          }
        }
      }
    }else{
      System.out.println("您输入的排序方式有误！");
    }
   }

   private void swap(int[] arr,int i,int j){
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
   }

   */***
    *** 
    *** *@*param arr
    *** *@*param value
    *** *@*return *返回*value*值出现的位置* *或* *-1**：未找到*
    **/*
   public int getValue(int[] arr, int value) {
    *//**方法：线性查找*
    for(int i = 0;i < arr.length;i++){
      if(value == arr[i]){
        return i;
      }
    }
    

    return - 1;

   }
 }

[修饰符] class 类名{
   [修饰符] 构造器名(){
     *//* *实例初始化代码*
   }
   [修饰符] 构造器名(参数列表){
     *//* *实例初始化代码*
   }
 }

public class Student {
   private String name;
   private int age;

   *//* *无参构造*
   public Student() {}

   *//* *有参构造*
   public Student(String n,int a) {
     name = n;
     age = a;
   }

   public String getName() {
     return name;
   }
   public void setName(String n) {
     name = n;
   }
   public int getAge() {
     return age;
   }
   public void setAge(int a) {
     age = a;
   }

   public String getInfo(){
     return "姓名：" + name +"，年龄：" + age;
   }
 }

public class TestStudent {
   public static void main(String[] args) {
     *//**调用无参构造创建学生对象*
     Student s1 = new Student();

     *//**调用有参构造创建学生对象*
     Student s2 = new Student("张三",23);
     
     System.out.println(s1.getInfo());
     System.out.println(s2.getInfo());

   }
 }

  public class JavaBean {
  private String name; *//* *属性一般定义为private*
  private int age;
  public JavaBean() {
  }
  public int getAge() {
    return age;
  }
  public void setAge(int a) {
    age = a;
  }
  public String getName() {
    return name;
  }
  public void setName(String n) {
    name = n;
  }
}

public class Boy {
    private String name;  //name和age前面写的负号  说明是私有属性
    private String age;

    public void setAge(String age){  //set方法传入的就可以是age  使用this.age=age可以区分传入的局部变量
        this.age=age;
    }

    public void setName(String name){  //set方法传入的就可以是name  使用this.name=name可以区分传入的局部变量
        this.name=name;
    }

    public String getAge(){
        return this.age;  //this可以省略
    }

    public String getName(){
        return this.name; //this可以省略
    }

    public void marry(Girl girl){
		
    }

    public void shout(){

    }
    
    public Boy(){
    
    }
    
    public Boy(String name,String age){
    	this.name=name;  //this()可以调用无参构造器
    	this.age=age;
    }
    
}

public class Girl {
    private String name;  //name和age前面写的负号  说明是私有属性
    private String age;

    public void setAge(String age){     //set方法传入的就可以是age  使用this.age=age可以区分传入的局部变量
        this.age=age;
    }

    public void setName(String name){   //set方法传入的就可以是name  使用this.name=name可以区分传入的局部变量
        this.name=name;
    }

    public String getAge(){
        return this.age;  //this可以省略
    }

    public String getName(){ 
        return this.name;  //this可以省略
    }

    public void marry(Boy boy){

    }

    public void compare(Girl girl){

    }
}

public class Account {
    private double balance; //因为balance前面是负号

    //前面一个加号是public 加横线了就是构造器
    public Account(double balance){
        this.balance=balance; //使用this区分成员变量和局部变量
    }

    //前面一个加号是public  冒号后面是double是返回值
    public double getBalance(){
        return this.balance;  //this可以省略
    }

    public void deposit(double amt){  //存钱
        if(amt>0){
            this.balance+=amt;
            System.out.println("存入成功!!!");
        }
    }

    public void withdraw(double amt){  //取钱
        if(amt>this.balance){
            System.out.println("余额不足!!!");
            return;  //跳出结果
        }
        this.balance-=amt;
    }

}

public class Customer {
    private String firstName;   //三个属性都是负号 所以设定为私有private
    private String lastName;    //三个属性都是负号 所以设定为私有private
    private Account account;    //三个属性都是负号 所以设定为私有private

    //正号所以是public  下划线所以是构造器
    public Customer(String f,String l){
        this.firstName=f;
        this.lastName=l;
    }

    //有冒号 说明有返回值
    public String getFirstName(){
        return this.firstName;
    }

    //有冒号 说明有返回值
    public String getLastName(){
        return this.lastName;
    }

    //有冒号 说明有返回值
    public Account getAccount(){
        return this.account;
    }

    //没有冒号 说明没有返回值
    public void setAccount(Account acct){
        this.account=acct;
    }

}

public class Bank {
    private Customer[] customers;  //私有化不能get和set创建
    private int numberOfCustomer;

    public Bank(){
        customers = new Customer[10];  //要初始化 不然BankTest会出现customers是null!!!
    }

    public void addCustomer(String f,String l){
        Customer customer=new Customer(f,l);  //新创建的顾客
        customers[this.numberOfCustomer++]=customer;  //将顾客添加到顾客数组
    }

    public int getNumberOfCustomer(){
        return this.numberOfCustomer;
    }

    public Customer getCustomer(int index){
        if(index < 0 || index >= numberOfCustomer){
            return null;
        }
        return customers[index];   //返回对应位置的顾客
    }

}

public class BankTest {
    public static void main(String[] args) {
        Bank bank = new Bank();

        bank.addCustomer("操","曹");
        bank.addCustomer("备","刘");

        bank.getCustomer(0).setAccount(new Account(1000)); //银行类bank获取第一个顾客，顾客设定一个账户，账户里面有1000余额
        bank.getCustomer(0).getAccount().withdraw(50);  //余额取出50

        System.out.println("账户余额为：" + bank.getCustomer(0).getAccount().getBalance()); //获取余额950

    }
}