Java学习Day08（第四章面向对象）

设计类Circle计算圆的面积

package com.aiguigu.exer;
//设计类Circle计算圆的面积

public class CircleTest {
    public static void main(String[] args) {
        Circle c1 = new Circle();
        c1.radius = 2.1;
        System.out.println(c1.findArea());
    }
}

//圆
class Circle{
    //属性
    double radius;
    //求圆的面积的方法
    public double findArea(){
        double area = Math.PI * radius * radius;
        return area;

    }
}

画*矩阵

package com.aiguigu.exer;

public class Exer3Test {
    public static void main(String[] args) {
        Exer3Test test = new Exer3Test();
        System.out.println(test.method(10, 8));
    }



    public int method(int m,int n){
        for(int i = 0;i < m;i++){
            for(int j = 0;j< n;j++){
                System.out.print("* ");
            }
            System.out.println();
        }

        return m * n;
    }
}

练习：学生

package com.aiguigu.exer;

public class StudentTest {
    public static void main(String[] args) {
        //声明一个student数组
        Student[] stus = new Student[20];

        for(int i = 0;i < 20;i++){
            stus[i] = new Student();
            //给Student对象的属性赋值
            stus[i].number = i + 1;
            stus[i].state = (int)(Math.random() * 6 + 1);
            //成绩
            stus[i].score = (int)(Math.random()*(101));


        }
        //遍历学生数组
        for(int i = 0;i < stus.length;i++){
            //System.out.println(stus[i].number +
            //        "," + stus[i].score + "," + stus[i].state);
            System.out.println(stus[i].info());
        }

        System.out.println("*********************************");
        for(int i = 0;i < stus.length;i++){
            if(stus[i].state == 3){
                System.out.println(stus[i].info());
            }
        }
        System.out.println("*********************************");
        for(int i = 0;i < stus.length - 1;i++){
            for(int j = 0;j < stus.length - 1 - i;j++){
                if(stus[j].score > stus[j + 1].score){
                    //如果需要换序，交换的是数组的元素，Student对象
                    Student temp = stus[j];
                    temp =stus[j];
                    stus[j] = stus[j + 1];
                    stus[j + 1] = temp;
                }

            }
        }

        //遍历学生数组
                for(int i = 0;i < stus.length;i++){
                    //System.out.println(stus[i].number +
                    //        "," + stus[i].score + "," + stus[i].state);
                    System.out.println(stus[i].info());    

                }
        }
}
class Student{
    int number;//学号
    int state;//年纪
    int score;//成绩

    //显示学生信息的方法
    public String info(){
        return "学号：" + number + "，年级：" + state + "，成绩" + score;

    }
}

练习：学生（优化）

package com.aiguigu.exer;
/*
 * 此代码是对StudentTest的优化，将操作数组封装到方法中
 */

public class StudentTest1 {
    public static void main(String[] args) {
        //声明一个student1数组
        Student1[] stus = new Student1[20];

        for(int i = 0;i < 20;i++){
            stus[i] = new Student1();
            //给Student1对象的属性赋值
            stus[i].number = i + 1;
            stus[i].state = (int)(Math.random() * 6 + 1);
            //成绩
            stus[i].score = (int)(Math.random()*(101));


        }

        StudentTest1 test = new StudentTest1();

        //遍历学生数组
        test.print(stus);

        System.out.println("*********************************");

        //查找年纪为3的学生

        test.searchState(stus, 3);

        System.out.println("*********************************");

        //冒泡排序

        test.sort(stus);

        //遍历学生数组

        test.print(stus);    
    }    




    //遍历Student1[]数组的操作
    public void print(Student1[] stus){
        for(int i = 0;i < stus.length;i++){
            //System.out.println(stus[i].number +
            //        "," + stus[i].score + "," + stus[i].state);
            System.out.println(stus[i].info());    

        }
    }    
    public void searchState(Student1[] stus,int state){
        for(int i = 0;i < stus.length;i++){
            if(stus[i].state == state){
                System.out.println(stus[i].info());
            }    
        }
    }
    //换序
    public void sort(Student1[] stus){
        for(int i = 0;i < stus.length - 1;i++){
            for(int j = 0;j < stus.length - 1 - i;j++){
                if(stus[j].score > stus[j + 1].score){
                    //如果需要换序，交换的是数组的元素，Student对象
                    Student1 temp = stus[j];
                    temp =stus[j];
                    stus[j] = stus[j + 1];
                    stus[j + 1] = temp;
                }

            }
        }

    }

}
class Student1{
    int number;//学号
    int state;//年纪
    int score;//成绩

    //显示学生信息的方法
    public String info(){
        return "学号：" + number + "，年级：" + state + "，成绩" + score;

    }
}

对象的知识补充

* 一、理解“万事万物皆对象”
 * 
 * 1.在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构
 *         >Scanner,String
 *         >文件：File
 *         >网络资源:URL
 * 2.涉及到Java语言与前端Html,后端的数据库交互时，前后端的结构在Java层面交互式，都体现为类，对象
 * 
 * 二、内存解析的说明
 * 1.引用类型的变量，只可能存储两类值：Null 或地址值（含变量类型）
 * 
 * 三、匿名对象的使用
 * 1.理解：我们创建的对象，没有显式的赋给一个变量名，即为匿名对象
 * 2.特征：匿名对象只能调用一次

4.5 类的成员之二：方法

1.方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中
也称为函数或过程。
2.将功能封装为方法的目的是，可以实现代码重用，简化代码
3.Java里的方法不能独立存在，所有的方法必须定义在类里。

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

4.6再谈方法

4.6.1重载

重载的概念
在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数
类型不同即可。
重载的特点：
与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类
型)。调用时，根据方法参数列表的不同来区别。
重载示例：

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

package com.atguigu;
/*
 * 1.重载举例
 * 
 * 2.判断是否是重载：
 *     跟方法的权限修饰符，返回值类型，形参变量名，方法体都没有关系
 * 
 * 3.在通过对象调用方法时，如何确定某一个指定的方法：
 *         方法名--->参数列表
 * 
 */
public class OverLoadTest {
    public void getSum(int i,int j){

    }

    public void getSum(double d1,double d2){

    }
}

4.6.2可变个数形参

package com.atguigu;
/*
 * 可变个数形参的方法
 * 
 * 1.jdk 5.0新增的内容
 * 2.具体使用
 *     2.1 可变个数形参的格式，数据类型....变量名
 *  2.2 当调用可变个数形参的方法时，传入的参数个数可以是0个1个多个
 *  2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
 *  2.4 可变个数形参的方法与本类中方法名相同，形参也相同的方法之间不构成重载
 *  2.5 可变个数形参在方法的形参中，必须声明在末尾
 *  2.6 可变个数形参在方法的形参中，最多声明一个可变形参
 */

public class MethodArgsTest {

        public static void main(String[] args) {


            MethodArgsTest test = new MethodArgsTest();
            test.show(12);
            test.show("Hello","world");


        }        


    public void show(int i){


    }
    public void show(String ...strs){
        System.out.println("show(String.....strs)");

    }




}

4.6.3方法参数的值传递机制

package com.atguigu;
/*
 * 关于变量的赋值
 * 
 *   如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
 *   如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。
 *   
 */
public class ValueTransferTest {
    public static void main(String[] args) {

        System.out.println("***************基本数据类型：*************");
        int m = 10;
        int n = m;
        System.out.println("m = " + m + ", n = " + n);

        n = 20;
        System.out.println("m = " + m + ", n = " + n);
        System.out.println("***************引用数据类型：************");
        Order o1 = new Order();
        o1.orderId = 1001;
        Order o2 = o1;//赋值以后，o1和o2的地址值相同，都指向了堆空间中的同一个对象主体
        System.out.println("o1.orderId = " + o1.orderId + " ,o2.orderId = " + o2.orderId);
    }
}

class Order{
    int orderId;



}

package com.atguigu;
/*
 * 方法的形参的传递机制，值传递
 * 
 * 1.形参，方法定义时，声明小括号内的参数
 * 2.实参，方法调用时，实际传递给形参的数据
 * 
 * 2.值传递机制：
 * 如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
 * 如果参数是引用数据类型，此时实参赋给形参的实参存储数据的地址值。
 */
public class ValueTransfer1 {
    public static void main(String[] args) {

        //交换两个变量的值的操作
        int m = 10;
        int n = 20;
        System.out.println("m = " + m + ", n = " + n);
        ValueTransfer1 test = new ValueTransfer1();
        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;
        System.out.println("m = " + m + ", n = " + n);
    }
}

4.6.4 递归方法

package com.atguigu;
/*
 * 递归方法的使用（了解）
 * 1.递归方法：一个方法体内调用它自身
 * 2.方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无需循环控制。
 *   递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
 */
public class RecursionTest {
    public static void main(String[] args) {



    //例1：计算1-100之间所有自然数的和
    //方式一
        //int sum = 0;
        //for(int i = 1;i <= 100;i++){
        //sum += i;
        //}
    //方式二：
        RecursionTest test = new RecursionTest();
        int sum = test.getSum(100);
        System.out.println(sum);
        System.out.println("*********************");
        int value =test.f(10);
        System.out.println(value);
    }
    public int getSum(int n){
        if(n == 1){
            return 1;


        }else{
            return n + getSum(n - 1);
        }

    }

    //例3：已知有一个数列：f(0) = 1,f(1) = 4,f(n+2) = 2*f(n+1) + f(n),
    //其中n是大于0的整数，求f（10）的值。
    public int f(int n){
        if(n == 0){
            return 1;
        }else if(n == 1){
            return 4;
        }else{
            return 2*f(n - 1) + f(n - 2);
        }

    }
    //例4.斐波那契数列

    //例5.汉诺塔问题

    //例5：快排

}