Java——面对对象基础

类与对象

题目：

=========================================================
代码：

import java.util.Scanner;
public class Learning {
    public static void main(String[] args){

        //创建一个猫对象（即创建一个实例）
        Cat cat1 = new Cat();// new Cat()创建一只猫,把创建的猫赋给cat1
        Cat cat2 = new Cat();

        cat1.name = "小白";//cat1的name属性为“小白“
        cat1.age = 3;//cat1的age属性为3
        cat1.color = "白色";//cat1的color属性为“白色“

        cat2.name = "小花";//cat1的name属性为“小花“
        cat2.age = 100;//cat1的age属性为100
        cat2.color = "花色";//cat1的color属性为“花色“

        //怎么访问对象的属性？
        System.out.println("第一只猫的信息为："
                + cat1.name +"," + cat1.age +"," + cat1.color);
        System.out.println("第二只猫的信息为："
                + cat2.name +"," + cat2.age + "," +cat2.color);
    }
}

//自定义一个类class，名字叫Cat
class Cat{
    //定义Cat这个类的属性（成员变量  n                                       nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn）
    String name;
    int age;
    String color;
    }

方法（成员方法）

入门了解代码

public class Learning {
    public static void main(String[] args){
        Person p3 = new Person();//1，创建对象
        p3.speak();//2，调用方法speak
        p3.count();//调用方法count
        p3.cal( 100 );

        int sum = p3.getSum(10,5);
        System.out.println("gesSum的返回值=" + sum);

    }
}

class Person{

//    public:表示方法是公开的  void:表示方法没有返回值  
// 	  speak（）:speak是方法名,（）为形参列表
//    1，定义一个方法speak，输出一句话
    public void speak() {
        System.out.println( "我是一个好人" );
    }

    //2，定义一个方法count，计算1+2+......+100的结果
    public void count() {
        int res = 0;
        for( int i = 1; i <= 100 ;i++){
            res += i;
        }
        System.out.println("输出结果=" + res);
    }

    //3，方法calculate，接收参数n，计算1+2+.....+n
    public void cal(int n){//n为形式参数，可以接收用户输入
        int res =0;
        for( int i = 1; i <= n ;i++){
            res += i;
        }
        System.out.println("计算结果为=" + res);
    }

    //4，输入两个数，计算和
    // int：表示该方法执行后返回一个int值
    public int getSum(int n1, int n2){
        int res = n1 + n2;
        return res;
    }
}

练习题
//定义一个类AA。 定义一个方法，Boolean型，用来判断输入数字的奇偶，奇数为false，偶数为true

public class Learning {
    public static void main(String[] args){
        //定义一个类AA，定义一个方法，Boolean型，用来判断输入数字的奇偶，奇数为false，偶数为true
        AA deter = new AA();

        //1,一种输出方法
        boolean result = deter.determine(8);
        System.out.println( result );

        //2,另一种输出方法
        //deter.determine()返回值为boolean型，如果为true，即是奇数
        if( deter.determine(8)){
            System.out.println("奇数");
        }else{
            System.out.println("偶数");
        }
    }
}
class AA{
    public boolean determine(int num){
//        if( num % 2 != 0 ){
//          return true;
//        }else{
//            return false;
//        }
        //效果与上面的if-else效果一致，不能整除为奇数，返回true
        return num % 2 != 0 ? true : false;

    }
}

方法的传参机制

1. 基本数据类型：传递的是值（拷贝值），形参的任何改变影响不了实参，所以在主函数中，实参不会因为调用了某个方法被改变。
2. 引用数据类型：传递的是地址，形参的改变会影响实参，所以调用某个方法以后可能会发生改变。若调用的方法，其语句置空，只是把自己的新开的栈置空，不会影响对象。

public class Learning {
    public static void main(String[] args){
        B b = new B();
        Person p = new Person();
        p.age = 10;

        b.test2(p);
        System.out.print("主方法"+ p.age);
    }
}

class Person{
    int age;
}

class B{
    public void test2(Person p){
        //情况1: 对象属性age被改变
        //主方法的p.age=20000，测试的p.age=20000
        p.age = 20000;

        //情况2：null置空，只是把test2的新开的栈置空，不会影响对象
        //主方法的p.age=10，测试的p.age不存在，会报错
        p = null;
        System.out.print("测试"+ p.age);

        //情况3：在test2里面新建一个对象（new Person），然后赋给形参p（指向它），（新创建的对象是对原对象的复制）
        //结果不会影响原对象，主方法的p.age=10，测试的p.age=30000
        p = new Person();
        p.age = 30000;
        System.out.print("测试"+ p.age);
    }

}

递归

递归：就是方法自己调用自己，可以解决汉诺塔、迷宫、八皇后等问题。

八皇后问题：在8×8格的国际象棋上摆放8个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。

入门例子：

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

        Test t = new Test();
        t.test(4);   //猜猜会输出什么？
    }
}

class Test{
    public void test(int n){
        if( n > 2){
           test(n-1);
        }
        System.out.println("n=" + n);
    }
}

输出
n=2
n=3
n=4
(方法里面自己调用自己，会有多个新开的栈，
栈像羽毛球筒一样，先开的栈在下面,因此后开的先出，先输出n=2)

阶乘

public class Learning {
    public static void main(String[] args){
        Test t = new Test();
        System.out.println( t.factorial(5) );
    }
}

class Test{

    //factorial阶乘
    public int factorial( int n){
        if( n == 1){
            return 1;
        }else{
            return factorial( n - 1) * n;
        }
    }
}

课堂练习 ——斐波那契数

斐波那契数：指的是这样一个数列：0，1，1，2，3，5，8，13，21，34，55，89，144……
它的规律是：这个数列从第 3 项开始，每一项都等于前两项之和。
在数学上，斐波那契数列以如下被以递推的方法定义：F(0)=0，F(1)=1, F(n)=F(n - 1)+F(n - 2)（n ≥ 2，n ∈ N*），显然，斐波那契数列是一个线性递推数列。

题目：输入一个数N，代表斐波那契数列的第N个数，然后输出这个数的值是多少

public class Learning {
    public static void main(String[] args){
        Test t = new Test();
        System.out.println(t.Fibonacci(8));
    }
}

class Test{
    //1: n=1,n=2, Fibonacci=1
    //2: n>=3, Fibonacci=前两项之和
    public int Fibonacci( int n){

        if( n == 1 || n== 2){
            return 1;
        }else{
            return ( Fibonacci(n-1) + Fibonacci(n-2) );
        }
    }
}

课堂练习—猴子吃桃

分析
//第10天，剩下1,day10=1
// 第9天，day10+1=2, 2x2=4 ,day9=4
// 第8天，day9+1=5, 5x2=10, day8=10
// 第七天，day8+1=11, 11x2=22, day7=22
// …
// 第1天，总数N

public class Learning {
    public static void main(String[] args){
        Test t = new Test();
        System.out.println(t.peach(1));//求第一天的桃子有多少
    }
}

class Test{
    //第10天，剩下1,day10=1
    // 第9天，day10+1=2, 2x2=4 ,day9=4
    // 第8天，day9+1=5, 5x2=10, day8=10
    // 第七天，day8+1=11, 11x2=22, day7=22
    // .........
    // 第1天，总数N
    public int peach( int day){
        if( day == 10){
            return 1;
        }else if( day >=1 && day <= 9){
            return  (peach(day+1) + 1) * 2;//后一天的个数+1，再乘以2
        }else{
            System.out.println("传入的天数day不对，10>=day>=1");
            return  -1;
        }

    }
}