面向对象设计

面向对象学习的三条主线

Java类及类的成员

属性、方法、构造器、代码块、内部类

面向对象的三大特征

封装性、继承性、多态性

其他关键字

this\super\static\final\abstract\interface\package\import

二“人把大象装进冰箱”

1.面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做

1. • 把冰箱打开
   • 抬起大象装进冰箱
   • 把冰箱门关闭
2. 面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做

人{

      打开（冰箱）{

           冰箱.开开（）；

}

抬起（大象）{

    大象.进入（冰箱）；

}

关闭（冰箱）{

冰箱.闭合（）；

}

}

冰箱{

         开开（）{}；

         闭合（）{}；

}

大象{

        进入（冰箱）{

}

}

三、面向对象的两个要素

类：对一类事物的描述，是抽象的、概念上的定义；

对象；是实际存在的该类事物的每个个体，因而也称为实例（instance）

>面向对象程序设计的重点是类的设计

>类的设计其实就是类的成员的设计

1. 设计类，就是设计类的成员
   属性 = 成员变量 = field = 域、字段
   方法 = 成员方法 = 函数
   创建类的对象 = 类的实例化 = 实例化类
   
   类和对象的使用（面向对象思想落地的实现）
   1.创建类，设计类的成员
   2.创建类的对象
   3.通过”对象.属性“或”对象.方法“调用对象的结构

类中属性的使用

属性（成员变量）  vs  局部变量
1.相同点：
   1.1定义变量的格式：数据类型 变量名= 变量值
   1.2先声明，后使用
   1.3变量都有其对应的作用域
2.不同点：
  2.1在类中声明的位置不同
  属性：直接定义在类的一对{}中
  局部变量：声明在方法类、方法形参、代码块内、构造器形参、构造器内部的变量

  2.2关于权限修饰符的不同
  属性：可以在声明属性时，指明其权限，是用权限修饰符号。
  常用的权限修饰符：private、public、缺省、protected
  局部变量：不可以使用权限修饰符

  2.3默认初始化值的情况：
  属性：类的属性，根据其类型，都有默认初始化值
       整形：0
       浮点型：0
       字符型：0或（'\u0000'）
       布尔型（boolean）：false
       引用数据类型（类、数组、接口）：null

  局部变量：没有初始化值
  意味着，我们在调用局部变量之前，一定要显示赋值。
  特别的：形参在调用前，我们赋值即可

  2.4在内存中加载的位置
  属性：加载到堆空间中（非static）
  局部变量；加载到栈空间

类中的声明的方法和使用

方法：
描述应该具有的功能
比如：Math类：sqrt（）\random()\..
     Scanner类：nextXxx（）....
     Arrays类：sort（）\binarySerach()\toString()\equals()\..
1.举例： *void 没有返回值的，否则需要返回值
        public void eat(){}
        public void sleep(int hour){}
        public  String getName(){}
        public String getNation(String nation){}
2.方法的声明：权限修饰符 返回值类型 方法名(形参列表){
                      方法体；
              }
3.说明：
    3.1权限修饰符：
       JAVA规定的四种权限修饰符：private（私有的）、public、缺省、protected
    3.2返回值类型：有返回值  vs  没有返回值
        3.2.1如果方法有返回值，则必须在方法声明时，指定返回值的类型，同时，方法值     需要使用  
        return关键字来返回指定类型的白能量或者常量
             如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中就
        不适用return，但是，如果使用的话，只能”return;“来表示结束此方法的意思
        3.2.2我们定义的方法该不该有返回值？
            ①看题目要求
            ②凭经验,具体问题具体分析
     3.3方法名：属于标识符，遵循标识符的规则和规范，”见明知意“
     3.4形参列表：方法可以声明0个，1个，或者多个
         3.4.1格式：数据类型1 形参1，数据类型2 形参2，...
         3.4.2我们定义方法时，该不该定义形参？
              ①看题目要求
              ②凭经验...............
     3.5方法体：
         方法功能的体现

4.return关键字的使用：
    4.1使用范围：使用在方法体中
    4.2作用：①结束方法
           ②针对于有返回值类型的方法，使用“return 数据“方法f返回所要的数据。
    4.3注意点：return 关键字后面不可以声明执行语句。
5.方法的使用中，可以调用当前类的属性或方法
             特殊的：方法A中又调用了方法A：递归方法

近几天所做的题目:

一、打印杨辉三角

/*
打印：
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
.........
 */
import java.util.Scanner;

public class yangHui {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int[][] arr1 =  new int[a][];
        //给数组元素赋值
        for(int i= 0;i < arr1.length;i++){
            arr1[i] =new int[i+1];
            //给数组首末赋值
            arr1[i][0] = 1;
            arr1[i][i] = 1;
            //给中间数组元素赋值
               for(int j = 1 ;j < arr1[i].length-1;j++){
                   arr1[i][j] = arr1[i-1][j-1] + arr1[i-1][j];
           }
        }
        //遍历一边二维数组
        for(int i= 0;i<arr1.length;i++){
            for(int j = 0 ; j <arr1[i].length;j++){
                System.out.print(arr1[i][j]+"  ");
            }
            System.out.println();

        }
    }
}

二、简单的面向对象设计

public class CustomerTest {
    public static void main(String[] ages){
        Customer c1 = new Customer();
        System.out.println(c1.age);
    }
}
//客户类
class Customer{
    //属性：
    String name;
    int age ;
    boolean isMale ;

    //方法
    public void eat(){
        System.out.println("和客户吃饭");
    }
    public void sleep(int hour){
        System.out.println("休息了"+hour+"个小时");
    }
    public  String getName(){
        return name;
    }
    public String getNation(String nation){
        String info = "我的国籍是："+nation;
        return info;
    }
}

三、计算圆的面积

package com.atguigu.exer;
/*
设计类 Circle 计算圆的面积
 */
import java.util.Scanner;

public class CircleTest {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        double R = sc.nextDouble();
        Circle c = new Circle();
        c.radius = R;
        System.out.println("圆的面积为："+ c.area());
    }
}
class Circle{
    //属性
    double radius;
    // 求圆的面积
    public double area(){
        double area = Math.PI * radius * radius;
        return area;
    }
}
四、

package com.atguigu.exer;
/*
3.1声明一个method方法，在方法中打印一个10*8的*型矩阵，在main方法中调用该方法
3.2修改上一个程序，在method方法中，除打印一个10*8的*型矩阵外，再计算该矩阵的面积，并将其
作为返回值。在main方法中调用该方法，接收返回的面积值并打印
3.3修改上一个程序，在method方法提供m和n两个参数，方法中打印一个m*n的*型矩形，并计算
该矩形的面积，将其作为方法返回值。在main方法中调用该方法，接收返回的面积值并打印
 */
public class Exer3Test {
    public static void main(String[] args) {
        Method1 m = new Method1();
        //3.1测试
         //m.method();
        //3.2
        //方式一：
        //int area = m.method();
        //System.out.println("面积为："+area);

        //方式二：
        //System.out.println(m.method());

        //3.3
        int area  = m.method(12,6);
        System.out.println("面积为："+area);
    }
}
class Method1{
    //3.1
    /**public void method(){
        for(int i = 0;i < 10 ; i++){
            for(int j = 0 ;j < 8; j++){
                System.out.print("*");
            }
            System.out.println();
        }
    }*/
    //3.2
    //public int  method(){
    //    for(int i = 0;i < 10 ; i++){
    //        for(int j = 0 ;j < 8; j++){
    //             System.out.print("*");
    //        }
    //        System.out.println();
    //    }
    //     return 10*8;
    //}
    //3.3
    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;
    }
}

五、

对象数组题目:
定义类Student，包含三个属性:学号number(int)，年级state(int)，成绩
score(int)。创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
问题一:打印出3年级(state值为3)的学生信息。
问题二:使用冒泡排序按学生成绩排序,并遍历所有学生信息
提示:
1)生成随机数:Math.random()，返回值类型double;
2)四舍五入取整:Math.round(double d)，返回值类型long.
5.声明一个日期类型MyDate:有属性:年year,月month，日day。
创建2个日期对象，分别赋值为:你的出生日期，你对象的出生日期，并显示信息。
 */

public class Exer4Test1 {
    public static void main(String[] args) {
        //声明Student1类型的数组
        Student1[] stus = new Student1[20];
        for(int i = 0;i<stus.length;i++){
            stus[i] = new Student1();
            //给Student对象的属性赋值
            stus[i].number = i+1 ;
            //年级【1-6】
            stus[i].state =(int) (Math.random()*(6-1+1)+1);
            //成绩：[0-100]
            stus[i].score = (int) (Math.random()*(100-0+1));
        }
        //遍历学生数组
        Exer4Test1 test = new Exer4Test1();
        test.print(stus);
        System.out.println("*************");
        //问题一：打印出3年级(state值为3)的学生信息。
        test.searchState(stus,3);
        System.out.println("*************");
        //问题二:使用冒泡排序按学生成绩排序,并遍历所有学生信息。
        test.sort(stus);
        //再次遍历
        test.print(stus);
    }
    /**
     * 遍历Student1[]数组的操作
     * @param stus
     */
    public void print(Student1[] stus){
        for(int i = 0; i<stus.length;i++){
            System.out.println(stus[i].info());
        }
    }

    /**
     * 找到年级为3的学生
     * @param stus
     * @param state
     */
    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());
            }
        }
    }

    /**
     * 给Student1排序
     * @param stus
     */
    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];
                    stus[j] = stus[j+1];
                    stus[j+1] = temp ;
                }
            }
        }
    }
}
class Student1{
    //属性
    int number;//学号
    int state;//年级
    int score;//成绩
    public String info(){
        return  "学号：" + number + "  年级：" + state + "  成绩：" + score;
    }
}