java学习笔记9
登录
标签搜索
侧边栏壁纸
博主昵称
bandao

  • 累计撰写 19 篇文章
  • 累计收到 1 条评论
java学习笔记

java学习笔记9

bandao
bandao
2021-12-12 / 0 评论 / 120 阅读 / 正在检测是否收录...

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

  1. Java类及类的成员：属性、方法、构造器；代码块、内部类
  2. 面向对象的三大特征：封装性、继承性、多态性、(抽象性)

  3. 其它关键字：this、super、static、final、abstract、interface、package、import等

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

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

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

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

    人{
      打开(冰箱){
          冰箱.开开();
      }
 
      抬起(大象){
          大象.进入(冰箱);
      }
 
      关闭(冰箱){
          冰箱.闭合();
      }
 
 }

冰箱{
       开开(){}
      闭合(){}
 }
 
大象{
      进入(冰箱){
      }
}

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

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

    4. 类和对象的使用

  4. 创建类，设计类的成员

    1. 属性 = 成员变量 = field = 域、字段
    2. 方法 = 成员方法 = 函数 = method
    3. 创建类的对象 = 类的实例化 = 实例化类
  5. 创建类的对象
  6. 通过“对象.属性”或“对象.方法”调用对象的结构

  7. 如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非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 局部变量

  8. 相同点：

    1. 定义变量的格式：数据类型 变量名 = 变量值
    2. 先声明，后使用
    3. 变量都有其对应的作用域

  9. 不同点：

    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. 方法的声明：

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

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

          3. Tip

  10. 关于权限修饰符：默认方法的权限修饰符先都使用public。
    Java规定的4种权限修饰符：private、public、缺省、protected

  11. 返回值类型： 有返回值 vs 没有返回值

    1. 如果方法有返回值，则必须在方法声明时，指定返回值的类型。并用return关键字来返回指定类型的变量或常量：“return 数据”。
      如果方法没有返回值，用void来表示。通常，没有返回值则不需要使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。

    2. 我们定义方法该不该有返回值？

      1. 题目要求
      2. 凭经验
  12. 方法名：属于标识符，遵循标识符的规则和规范，“见名知意”

  13. 形参列表： 方法可以声明0个，1个，或多个形参。

    1. 格式：数据类型1 形参1,数据类型2 形参2,...

    2. 我们定义方法时，该不该定义形参？

      1. 题目要求
      2. 凭经验
  14. 方法体：方法功能的体现。

  15. return关键字的使用：

    1. 使用范围：使用在方法体中

    2. 作用：

      1. 结束方法
      2. 针对于有返回值类型的方法，使用"return 数据"方法返回所要的数据。
    3. 注意点：return关键字后面不可以声明执行语句。
  16. 方法的使用中，可以调用当前类的属性或方法
    特殊的：方法A中又调用了方法A:递归方法。
    方法中，不可以定义方法。

  17. 可以直接在同一个包下面定义自己的类，名字尾缀为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;
 }
}
0
java类面向对象
版权属于： bandao
本文链接： https://joe.bandao.ltd/coding/java/note/9.html
作品采用： 《 署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0) 》许可协议授权
相关推荐
java学习笔记12
java学习笔记12
 java project 客户管理信息软件
java project 客户管理信息软件
 java学习笔记10
java学习笔记10
 java学习笔记8
java学习笔记8

评论 (0)

取消