day--13

方法回顾

• 方法定义

  1. 修饰符

  2. 返回值类型

  3. break：跳出 switch ,结束循环和 return 的区别

     return返回值要与定义的返回值类型相同。return 也标志此方法结束

  4. 方法名：注意规范就OK 见名知意原则

  5. 参数列表：（参数类型，参数名）...

• 三元运算符：a>b ? a:b //如果A大于B 就是A否则就是B

方法的调用：递归

• 静态方法

  和非静态的区别主要就是是否加了 static 静态方法的调用可以直接用 类名.方法名；非静态的需要先实例化类再 类名.方法名 调用

  public static void nain(string[] args){
      Student student = new Student(); //实例化Student这个类
      student.say(); //类名.方法名调用  如果是静态的方法 就不需要上一步  直接调用
  }
  
  Student类
  public class Student{
      public void say(){   //没有static所以是 非静态方法  上面调用时 就得先实例化
          System.out.println("学生说话")
      }
  }
  

  static 也就时静态方法 类创建时 就一起存在了， 而非静态方法时类实例化之后才存在。这就是为什么静态方法可以直接 类名.方法名（） 直接调用；而非静态的要先实例化。

• 非静态方法

• 形参和实参

  形参只是一个占位符，但是输入实际参数要与形参保持类型一致

• 值传递和引用传递

  值传递无关方法只是一个具体的数值，（个人理解）

  public class Method03 {
      public static void main(String[] args) {
          int a = 1;
          System.out.println(a);
          Method03.change(a);    
          System.out.println(a); //这里输出的a依然是1；跟下面的方法 a 无关。
      }
  
      public static int change(int a){
          a = 10;
          return a = 10;
      }
  }
  

  引用传递：传递的是一个对象 ， 当然本质还是数值。

• this关键字

类与对象的关系

• $\textcolor{red}{类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物}$

• 对象是抽象概念的具体实例

  总结一下就是，类是所有对象的概括。如果类是一个物种，那么对象就是这个物种里的一个具体动物。

  public class Student{
      //属性：字段
      String name; //默认的是null
      int age; //默认的是0
      
      //方法
      public void study(){
          System.out.println(this.name+"在学习")
      }
  }
  
  

  上面的是 Student 类，包含属性 和 方法

  下面调用的就是上面这个 Student 这个类

public class Application{  
    public static void main(string[] args){
        //类：抽象的，实例化
        //类实例化后会返回一个自己的对象！
        //student对象就是一个Student类的具体实例
        Student xiaoming = new Student（）；
        Student xh = new Student（）；
        
        xiaoming.name = "小明"；
        xiaoming.age = 3;
        
        xh.name = "小红"；
        xh.age = 3;
        
        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);
        
        System.out.println(xh.name);
        System.out.println(xh.name);
    }
}

插一句：一个项目应该只存在一个main方法。一般放在 Application里

任何类里面只有 属性和方法两样

什么是面向对象 (Object-Oriented Programming, OOP)

• 面向对象的本质就是：$\textcolor{red}{以类的方式组织代码，以对象的组织（封装）数据。}$

创建与初始化对象

• 使用 new 关键字创建对象

• 使用 new 关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及类中构造器的调用。类和构造器同时存在

• 类中构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点

  1. 必须和类的名字相同

  2. 必须没有返回类型，也不能写void

构造器

• 实例化初始值
• 使用 new关键字，本质是在调用构造器
• 一旦定义了有参构造，无参就必须显示定义，否则无意义
• 快捷键 alt+insert 自当生成构造器 注意有参和无参的选择

public class Person{
    //一个类即时什么都不写，它也会存在一个方法（构造器）
    String name;
    //1、使用new关键字，本质是在调用构造器。2、用来初始化值
    
    public Person(){  //无参构造器
        
    }
    
    
    
    //有参构造：一旦定义了有参构造，无参就必须显示定义，空着都行。
    public Person(String name){
        this.name = name;
    }
}



public static void main（String[] args){
    
    Person person = new Person();
    System.out.println(person.name);
}

构造器总结：
1.和类名相同
2.没有返回值
作用：
1.new 本质在调用构造方法
2.初始化对象的值
注意点：
1.定义有参构造之后，如果像使用无参构造，显示的定义一个无参的构造
快捷键：Alt + insert

.jpeg)

方法区都是堆里的

public static void main(string[] args){
    pet dog = new Pet();
    dog.name = "旺财"；
    dog.age = 3;
    dog.shout();
    System.out.println(dog.name);
    System.out.println(dog.age);
}

public class Pet{
    public String name;
    public int age;
    //无参构造
    public void shout(){
        System.out.println("叫了一声")
    }
}

总结

• 类与对象：

  1. 类是一个模板：抽象，

  2. 对象是一个具体的实例，

• 方法： 方法的定义和调用

• 对象的引用：

  1. 引用类型：除了八大类型都是引用类型；对象是通过引用来操作的：栈---->堆（通过引用栈里的变量名索引到堆里的地址来操作的，因为方法都在堆里）
  2. 基本类型：（八大基本类型）

• 属性：默认初始化，

  1. 数字：0
  2. char: u0000
  3. boolean: false
  4. 引用：null

• 万能赋值公式：修饰符 属性类型 属性名 = 属性值

• 对象的创建和使用

  1. 必须使用 new 关键字创造对象，构造器
  2. 对象的属性 调用：对象名.属性名
  3. 对象的方法 调用：对象名.方法名（）

• 类：

     1. 静态的属性    属性
     1. 动态的行为    方法
  

面向对象三大特性：封装 继承 多态

• 封装：(重点是对于属性的)
  1. 该露的露，该藏的藏
  1. 程序设计追求“高内聚，低耦合”。高内聚就是类的内部操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
  1. 封装（就是数据的隐藏）通常应该静止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
  1. 属性私有（private）后 就得通过 get/set 使用 get用来获取，set用来赋值

public class Student{
    //属性私有
    private String name;  //名字
    private int id;  //学号
    private char sex;  //性别
    
    //提供一些可以操作这个属性的方法  要像使用这些私有的属性 就必须提供一些public 的 get/set方法  
    public String getName(){  //get获得这个数据
        return this.name;
    }   
    public void setName(String name){
        this.name = name;
    
    }
}

public class Application{
    public static void main(String[] args){
        Student s1 = new Student();  //因为上面提供了public的  get / set 方法 所以这里才能这么使用
        s1.setName("遇见")；
        System.out.println(s1.getName());
    }
}

会在 set 里做一些判断  比如age人的寿命不可能无限大  所以在封装时就可以去规避如下
    
    public void setAge(int age){
         if(age>120 || age<0){
             this.age = 0;
         }else{
             this.age = age; 
         }
}

快捷键alt+insert 可以自动生成 get和set 方法

• 封装的意义
  1. 提高程序的安全性，保护数据
  2. 隐藏代码的实现细节
  3. 统一接口
  4. 增加了系统的可维护性