java学习笔记9

1. java 面向对象学习的三条主线

Java 类及类的成员：属性、方法、构造器；代码块、内部类
面向对象的三大特征：封装性、继承性、多态性、(抽象性)
其它关键字：this、super、static、final、abstract、interface、package、import 等

2. 面向对象和面向过程的区别

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

1
2
3

① 把冰箱门打开
② 抬起大象，塞进冰箱
② 把冰箱门关闭

面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

人{
         打开(冰箱){
             冰箱.开开();
         }

         抬起(大象){
             大象.进入(冰箱);
         }

         关闭(冰箱){
             冰箱.闭合();
         }

 }

冰箱{
          开开(){}
         闭合(){}
 }

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

3. 面向对象的两个要素：

类：对一类事物的描述，是抽象的、概念上的定义
对象：是实际存在的该类事物的每个个体，因而也称为实例(instance)
面向对象程序设计的重点是类的设计。设计类，就是设计类的成员。

4. 类和对象的使用

创建类，设计类的成员
1. 属性 = 成员变量 = field = 域、字段
2. 方法 = 成员方法 = 函数 = method
3. 创建类的对象 = 类的实例化 = 实例化类
创建类的对象
通过“对象.属性”或“对象.方法”调用对象的结构
如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非 static 的）意味着：如果我们修改一个对象的属性 a，则不影响另外一个对象属性 a 的值。

java 代码

package com.atguigu.java;

public class PersonTest {
    public static void main(String[] args) {
        //2. 创建Person类的对象
        Person p1 = new Person();

        //调用对象的结构：属性、方法
        //调用属性：“对象.属性”
        p1.name = "Tom";
        p1.isMale = true;
        System.out.println(p1.name);

        //调用方法：“对象.方法”
        p1.eat();
        p1.talk("中文");

        Person p2 = new Person();
        System.out.println(p2.name);        //null
        System.out.println(p2.isMale);      //false

        //将p1变量保存的对象地址值赋给p3,导致p1和p3指向了堆空间中的同一个对象实体。
        Person p3 = p1;
        System.out.println(p3.name);        //Tom

        p3.age = 10;
        System.out.println(p1.age);         //10
    }
}

//1.创建类，设计类的成员
class Person{
    String name;
    int age = 1;
    boolean isMale;

    public void eat() {
        System.out.println("eat");
    }
    public void sleep() {
        System.out.println("sleep");
    }
    public void talk(String language) {
        System.out.println("说的是" + language);
    }
}

5. 类中属性的使用

属性（成员变量） vs 局部变量

相同点：
1. 定义变量的格式：数据类型变量名 = 变量值
2. 先声明，后使用
3. 变量都有其对应的作用域
不同点：
1. 在类中声明的位置的不同
  
  属性：直接定义在类的一对{}内
  局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
2. 关于权限修饰符的不同
  
  属性：可以在声明属性时，指明其权限，使用权限修饰符。
  常用的权限修饰符：private、public、缺省(default)、protected —>封装性。缺省常用。
  局部变量：不可以使用权限修饰符。
3. 默认初始化值的情况：
  1. 属性：类的属性，根据其类型，都有默认初始化值。
    1. 整型（byte、short、int、long）：0
    2. 浮点型（float、double）：0.0
    3. 字符型（char）：0 （或’\u0000’）
    4. 布尔型（boolean）：false
    5. 引用数据类型（类、数组、接口）：null
  2. 局部变量：没有默认初始化值。
    1. 意味着，我们在调用局部变量之前，一定要显式赋值。
    2. 特别地：形参在调用时，我们赋值即可。
  3. 在内存中加载的位置：
    1. 属性：加载到堆空间中（非 static）
    2. 局部变量：加载到栈空间

6. 类中方法的声明和使用

1. 方法：描述类应该具有的功能。

比如：Math 类：sqrt()\random() ...
Scanner 类：nextXxx() …
Arrays 类：sort() \ binarySearch() \ toString() \ equals() \ …

下面是自己写的类：
public void eat(){}
public void sleep(int hour){}
public String getName(){}
public String getNation(String nation){}

2. 方法的声明：

1
2
3

权限修饰符  返回值类型  方法名(形参列表){
                    方法体
              }

注意：static、final、abstract 来修饰的方法

3. Tip

关于权限修饰符：默认方法的权限修饰符先都使用 public。
Java 规定的 4 种权限修饰符：private、public、缺省、protected
返回值类型：有返回值 vs 没有返回值
1. 如果方法有返回值，则必须在方法声明时，指定返回值的类型。并用 return 关键字来返回指定类型的变量或常量：“return 数据”。
  如果方法没有返回值，用 void 来表示。通常，没有返回值则不需要使用 return.但是，如果使用的话，只能“return;”表示结束此方法的意思。
2. 我们定义方法该不该有返回值？
  1. 题目要求
  2. 凭经验
方法名：属于标识符，遵循标识符的规则和规范，“见名知意”
形参列表：方法可以声明 0 个，1 个，或多个形参。
1. 格式：数据类型 1 形参 1,数据类型 2 形参 2,…
2. 我们定义方法时，该不该定义形参？
  1. 题目要求
  2. 凭经验
方法体：方法功能的体现。
return 关键字的使用：
1. 使用范围：使用在方法体中
2. 作用：
  1. 结束方法
  2. 针对于有返回值类型的方法，使用”return 数据”方法返回所要的数据。
3. 注意点：return 关键字后面不可以声明执行语句。
方法的使用中，可以调用当前类的属性或方法
特殊的：方法 A 中又调用了方法 A:递归方法。
方法中，不可以定义方法。
可以直接在同一个包下面定义自己的类，名字尾缀为 java，最开始不需要 import

package com.atguigu.exer;

public class Person {
    String name;
    int age;
    /**
     * sex:1 表明是男性
     * sex:0 表明是女性
     */
    int sex;
    public  void study(){
        System.out.println("studying");
    }
    public void showAge(){
        System.out.println("age:" + age);
    }
    public int addAge(int i){
        age += i;
        return age;
    }
}

package com.atguigu.exer;
/*
 * 要求：
 * (1)创建Person类的对象，设置该对象的name、age和sex属性，调用study方法，
 * 输出字符串“studying”，调用showAge()方法显示age值，
 * 调用addAge()方法给对象的age属性值增加2岁。
 * (2)创建第二个对象，执行上述操作，体会同一个类的不同对象之间的关系。
 */
public class PersonTest {
    public static void main(String[] args) {
        Person p1 = new Person();

        p1.name = "Tom";
        p1.age = 18;
        p1.sex = 1;

        p1.study();
        p1.showAge();

        int newAge = p1.addAge(2);
        System.out.println(p1.name + "的新年龄为：" + newAge);
        System.out.println(p1.age);             //20

        Person p2 = new Person();
        p2.showAge();                           //0
        p2.addAge(10);
        p2.showAge();                           //10

    }
}

4. java 代码

package com.atguigu.java;

public class CustomerTest {
    public static void main(String[] args) {
        Customer cust1 = new Customer();
        //cust1.eat();      报错
        cust1.sleep(8);

    }
}
class Customer{
    String name;
    int age;
    boolean isMale;

    private void eat(){
        System.out.println("客户吃饭");
    }

    public  void sleep(int  hour){
        System.out.println("休息了" + hour + "个小时");
        eat();
    }

    public String getName(){
        if (age > 18){
            return name;
        }else {
            return "Tom";
        }
    }

    public String getNation(String nation){
        String info = "国籍为" + nation;
        return info;
    }
}

package com.atguigu.java;

public class UserTest {
    public static void main(String[] args) {
        User u1 = new User();
        System.out.println(u1.name);
        System.out.println(u1.age);
        System.out.println(u1.isMale);

        u1.talk("汉语");
        u1.eat();
    }
}
class User{
    //属性（或成员变量）
    String name;
    public int age;
    boolean isMale;

    public void talk(String language){           //局部变量
        System.out.println("我们用" + language);
    }
    public void eat(){
        String food = "饼";                      //局部变量
        System.out.println("一个" + food);
    }
}

package com.atguigu.exer;

public class StudentTest1 {
    public static void main(String[] args) {
        Student1[] s1 = new Student1[20];
        for (int i = 0; i < s1.length; i++) {
            s1[i] = new Student1();
            s1[i].number = (i + 1);
            //年级：[1,6]
            s1[i].state = (int)(Math.random() * (6 - 1 + 1) + 1);
            //成绩：[0,100]
            s1[i].score = (int) (Math.random() * (100 - 0 + 1));
        }
        StudentTest1 test = new StudentTest1();
        test.print(s1);
        System.out.println();

        test.seacchState(s1, 3);
        System.out.println();

        test.sort(s1);
        test.print(s1);

    }


    /**
     * 遍历学生数组
     * @param s1
     */
    public void print(Student1[] s1){
        for (int i = 0; i < s1.length; i++) {
            System.out.println(s1[i].info());
        }
    }

    /**
     *问题一：打印出指定年级的学生信息。
     * @param s1 要查找的数组
     * @param state 要查找的年级
     */
    public void seacchState(Student1[] s1, int state){
        for (int i = 0; i < s1.length; i++) {
            if (s1[i].state == state){
                System.out.println(s1[i].info());
            }
        }
    }

    /**
     * 使用冒泡排序按学生成绩排序
     * @param s1
     */
    public  void sort(Student1[] s1){
        for (int i = 0; i < s1.length - 1; i++) {
            for (int j = 0; j < s1.length - 1 - i; j++) {
                if (s1[j].score > s1[j + 1].score){
                    //注意这里交换的是对象
                    Student1 temp = s1[j];
                    s1[j] = s1[j + 1];
                    s1[j + 1] = temp;
                }
            }
        }
    }
}

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

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

本文采用署名-非商业性使用-相同方式共享 4.0 国际许可协议，转载请注明出处。