JavaSE笔记（二）

Java对象和多态 （面向对象）

面向对象基础

面向对象程序设计(Object Oriented Programming)

对象基于类创建，类相当于一个模板，对象就是根据模板创建出来的实体（就像做月饼，我们要做一个月饼首先需要一个模具，模具就是我们的类，而做出来的月饼，就是类的实现，也叫做对象），类是抽象的数据类型，并不能代表某一个具体的事物，类是对象的一个模板。类具有自己的属性，包括成员变量、成员方法等，我们可以调用类的成员方法来让类进行一些操作。

Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
System.out.println("你输入了："+str);
sc.close();

所有的对象，都需要通过new关键字创建，基本数据类型不是对象！Java不是纯面对对象语言！

不是基本类型的变量，都是引用类型，引用类型变量代表一个对象，而基本数据类型变量，保存的是基本数据类型的值，我们可以通过引用来对对象进行操作。（最好不要理解为引用指向对象的地址，初学者不要谈内存，学到JVM时再来讨论）

对象占用的内存由JVM统一管理，不需要手动释放内存，当一个对象不再使用时（比如失去引用或是离开了作用域）会被JVM自动清理，内存管理更方便！

---

类的基本结构

为了快速掌握，我们自己创建一个自己的类，创建的类文件名称应该和类名一致。

成员变量

在类中，可以包含许多的成员变量，也叫成员属性，成员字段(field)通过.来访问我们类中的成员变量，我们可以通过类创建的对象来访问和修改这些变量。成员变量是属于对象的！

public class Test {
   
    int age;
    String name;
}

public static void main(String[] args) {
   
    Test test = new Test();
    test.name = "奥利给";
    System.out.println(test.name);
}

成员变量默认带有初始值，也可以自己定义初始值。

成员方法

我们之前的学习中接触过方法(Method)吗？主方法！

public static void main(String[] args) {
   
  //Body
}

方法是语句的集合，是为了完成某件事情而存在的。完成某件事情，可以有结果，也可以做了就做了，不返回结果。比如计算两个数字的和，我们需要得到计算后的结果，所以说方法需要有返回值；又比如，我们只想吧数字打印在控制台，只需要打印就行，不用给我结果，所以说方法不需要有返回值。

方法的定义和使用

在类中，我们可以定义自己的方法，格式如下：

[返回值类型] 方法名称([参数]){
   
  //方法体
  return 结果;
}

• 返回值类型：可以是引用类型和基本类型，还可以是void，表示没有返回值
• 方法名称：和标识符的规则一致，和变量一样，规范小写字母开头！
• 参数：例如方法需要计算两个数的和，那么我们就要把两个数到底是什么告诉方法，那么它们就可以作为参数传入方法
• 方法体：方法具体要干的事情
• 结果：方法执行的结果通过return返回（如果返回类型为void，可以省略return）

非void方法中，return关键字不一定需要放在最后，但是一定要保证方法在任何情况下都具有返回值！

int test(int a){
   
  if(a > 0){
   
    //缺少retrun语句！
  }else{
   
    return 0;
  }
}

return也能用来提前结束整个方法，无论此时程序执行到何处，无论return位于哪里，都会立即结束个方法！

void main(String[] args) {
   
   for (int i = 0; i < 10; i++) {
   
       if(i == 1) return;   //在循环内返回了！和break区别？
   }
   System.out.println("淦");   //还会到这里吗？
}

传入方法的参数，如果是基本类型，会在调用方法的时候，对参数的值进行复制，方法中的参数变量，不是我们传入的变量本身！

public static void main(String[] args) {
   
    int a = 10, b = 20;
  new Test().swap(a, b);
  System.out.println("a="+a+", b="+b);
}

public class Test{
   
 void swap(int a, int b){
     //传递的仅仅是值而已！
  int temp = a;
  a = b;
 b = temp;
} 
}

传入方法的参数，如果是引用类型，那么传入的依然是该对象的引用！（类似于C语言的指针）

public class B{
   
 String name;
}

public class A{
   
 void test(B b){
     //传递的是对象的引用，而不是值
    System.out.println(b.name);
  }
}

public static void main(String[] args) {
   
    int a = 10, b = 20;
  B b = new B();
  b.name = "lbw";
  new A().test(b);
  System.out.println("a="+a+", b="+b);
}

方法之间可以相互调用

void a(){
   
  //xxxx
}

void b(){
   
  a();
}

当方法在自己内部调用自己时，称为递归调用（递归很危险，慎重！）

int a(){
   
  return a();
}

成员方法和成员变量一样，是属于对象的，只能通过对象去调用！

---

对象设计练习

• 学生应该具有以下属性：名字、年龄
• 学生应该具有以下行为：学习、运动、说话

---

方法的重载

一个类中可以包含多个同名的方法，但是需要的形式参数不一样。（补充：形式参数就是定义方法需要的参数，实际参数就传入的参数）方法的返回类型，可以相同，也可以不同，但是仅返回类型不同，是不允许的！

public class Test {
   
    int a(){
      //原本的方法
       return 1;
    }

    int a(int i){
     //ok，形参不同
        return i;
    }
    
    void a(byte i){
     //ok，返回类型和形参都不同
        
    }
    
    void a(){
     //错误，仅返回值类型名称不同不能重载
        
    }
}

现在我们就可以使用不同的参数，但是支持调用同样的方法，执行一样的逻辑：

public class Test {
   
    int sum(int a, int b){
      //只有int支持，不灵活！
        return a+b;
    }
    
    double sum(double a, double b){
     //重写一个double类型的，就支持小数计算了
        return a+b;
    }
}

现在我们有很多种重写的方法，那么传入实参后，到底进了哪个方法呢？

public class Test {
   
    void a(int i){
   
        System.out.println("调用了int");
    }

    void a(short i){
   
        System.out.println("调用了short");
    }

    void a(long i){
   
        System.out.println("调用了long");
    }

    void a(char i){
   
        System.out.println("调用了char");
    }

    void a(double i){
   
        System.out.println("调用了double");
    }

    void a(float i){
   
        System.out.println("调用了float");
    }
  
  public static void main(String[] args) {
   
        Test test = new Test();
        test.a(1);   //直接输入整数
        test.a(1.0);  //直接输入小数

        short s = 2;
        test.a(s);  //会对号入座吗？
        test.a(1.0F);
    }
}

构造方法

构造方法（构造器）没有返回值，也可以理解为，返回的是当前对象的引用！每一个类都默认自带一个无参构造方法。

//反编译结果
package com.test;

public class Test {
   
    public Test() {
       //即使你什么都不编写，也自带一个无参构造方法，只是默认是隐藏的
    }
}

反编译其实就是把我们编译好的class文件变回Java源代码。

Test test = new Test();  //实际上存在Test()这个的方法，new关键字就是用来创建并得到引用的
// new + 你想要使用的构造方法

这种方法没有写明返回值，但是每个类都必须具有这个方法！只有调用类的构造方法，才能创建类的对象！

类要在一开始准备的所有东西，都会在构造方法里面执行，完成构造方法的内容后，才能创建出对象！

一般最常用的就是给成员属性赋初始值：

public class Student {
   
    String name;
    
    Student(){
   
        name = "伞兵一号";
    }
}

我们可以手动指定有参构造，当遇到名称冲突时，需要用到this关键字

public class Student {
   
    String name;

    Student(String name){
      //形参和类成员变量冲突了，Java会优先使用形式参数定义的变量！
        this.name = name;  //通过this指代当前的对象属性，this就代表当前对象
    }
}

//idea 右键快速生成！

注意，this只能用于指代当前对象的内容，因此，只有属于对象拥有的部分才可以使用this，也就是说，只能在类的成员方法中使用this，不能在静态方法中使用this关键字。

在我们定义了新的有参构造之后，默认的无参构造会被覆盖！

//反编译后依然只有我们定义的有参构造！

如果同时需要有参和无参构造，那么就需要用到方法的重载！手动再去定义一个无参构造。

public class Student {
   
    String name;

    

原文地址：https://blog.csdn.net/m0_53870075/article/details/142701313

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！