【代码笔记】Java基础：Java的方法和类

1. 面向过程与面向对象都是我们编程中，编写程序的一种思维方式。例如：公司打扫卫生（擦玻璃、扫地、拖地、倒垃圾等），

   按照面向过程的程序设计方式会思考“打扫卫生我该怎么做，然后一件件的完成”，最后把公司卫生打扫干净了。

按照面向对象的程序设计方式会思考“我该让谁来做，如小明擦玻璃、让小丽扫地、让小郭拖地、让小强倒垃圾等”,这里的“小明、小丽、小郭、小强”就是对象，他们要打扫卫生，怎么打扫是他们自己的事，反正最后一群对象合力把公司卫生打扫干净了。

继续举例：

使用面向过程说明买电脑这件事：分析整个过程大体分一下几步：上网查询参数和报价、电脑城询价、现场安装和监督、抱电脑回家。在整个过程中我们参与了每一个细节，并且会感觉相当累。

使用面向对象说明买电脑这件事：只要找到懂电脑硬件的这个人，我们的问题都可以解决。并且在这个过程中我们不用那么辛苦。

所以，面向过程思维方式中更多的体现的是执行者（自己做事情），面向对象中更多的体现是指挥者（指挥对象做事情）。

1. Java作为一种面向对象的语言，具备三大特性（面向对象的核心）：封装性   继承性   多态性
1. 封装性：就是打包，所有东西都是打包好的。
2. 继承：子类可以继承父类
• 文件名：Student.java

• public class Student {
      public String name;
      public int age;
      
      public void study(){
          System.out.println("学生学习");
      }
  }

  文件名：Unstudent.java
  • 在上文中定义了普通方法学生（Student），并定义一个普通行为——普通类学习（study）
  • Student作为构造函数，构造函数是不能被继承，所以也不存在构造函数重写

• public class UnStudent extends Student{
      public void study(){
          System.out.println("大学生的学习方法");
      }
      public void playGame(){
          System.out.println("大学生玩dota");
      }
  }

  文件名：Test.java
  • 在上文中定义了普通方法大学生（Unstudent），并继承（extends）普通方法学生（Study）
  • 同时，它在子类（Unstudent），继承父类（Study）的前提，子类定义一个和父类相同的（方法名、参数、返回类型）方法（“public void study(){
    ”）。
  • 子类可以定义新的行为（类）“playGame”。

• public class Test {
      public static void main(String[] args) {    
          //自动转型
          UnStudent us = new UnStudent();
          Student us1 = new UnStudent();
          Student us2 = new Student();
          
          us.study();
          us1.study();
          us2.study();
          
          us.playGame();
          us1.playGame();
          us2.playGame();
      }
  }

  • 在上文中主函数里大学生（Unstudent）“ us ”构造一次，进行方法重载。“ us ”将具备普通方法UnStudent所有特性，并且进行方法重写的将覆盖父类原有的类的定义。
  • “ us1 ”具备Student所有属性，但被UnStudent重写的属性将会是UnStudent重写后的内容，原Student内类将会被覆盖，UnStudent内存在但Student不存在的类“ us1 ”将无法调用。
  • “ us2 ” 就是正宗Student类。
3. 1. 上面存在两种方法：
      • 自动转型
        定义：创建子类的对象，然后自动转型为父类的类型
        格式：父类类名  对象名  = new  子类类名();
      • 转型后的对象类型为转型后的类型，执行的方法如果子类重写了父类的方法，则执行的是重写后的，如果没有重写，则执行的是父类自己的
        如果没有自动转型过程，则执行的方法都是自己的方法
4. 因为存在自动转型和方法重写和继承等特性，所以Java语言呈现多态性。
   1. 多个同一种类型的对象，执行同一个方法，执行的过程不一样(有区别)
   2. 为什么会有多态现象？？？
      • 自动转型+方法重写    
      • 自动转型+方法重写  将导致具有继承性，因此将具备多态性
2. Java语言的方法分类只有三种：
   1. 构造方法：public 类名( ){ }
   2. 普通方法：public 返回类型  方法名(参数){ }
   3. 抽象方法：public abstract 返回类型 方法名(参数);
3. Java语言类的分类也有三种：
   1. 普通类：public class 类名{}
      1. 只能有普通方法和构造方法，一定不能有抽象方法
      2. 可以创建对象
      3. 属性可以是常量（static final），也可以是变量
   2. 抽象类：public abstract class 类名{}
      1. 三种类型的方法都可以存在
      2. 不能创建对象
      3. 属性可以是常量（static final），也可以是变量
   3. 接口：public interface 类名(){}
      1. 只能有抽象方法，普通方法和构造方法不存在
      2. 不能创建对象
      3. 属性一定是常量（static final）
4. 接口和抽象类有什么用？文件名：Teacher.java
   1. 接口和抽象类的作用是用来当父类被继承的，抽象方法是用来指导子类重写(实现)的
   2. 关键子：implements
   3. 格式：
      • public class 子类类名  implements 接口名{
          //重写父类的所有的抽象方法
         }
   4. 接口无非就是领导，只是指导开发

5. public interface Teacher {
       public static final String name = "aa";
       public static final String job = "aa";
       public static final int age = 20;
       
       //抽象方法
       public abstract void play1();
       public abstract void play2();
       public abstract void play3();
       public abstract void play4();
       public abstract void play5();
   }

6. 文件名：UnTeacehr.java

   public abstract class UnTeacher implements Teacher{
       
   }

1. 在上文两个文件中“ Teacher ”类作为接口类（关键词  interface 表示接口类
2. 具备三个常量，不可更改。
3. 有抽象方法，无法实现和定义。

 7.多态

父类引用变量可以指向子类对象。

多态的前提是必须有子父类关系或者类实现接口关系，否则无法完成多态。

在使用多态后的父类引用变量调用方法时，会调用子类重写后的方法。

 

可以理解为：

有人找孔子他爹去给人上课，

到孔子家里发现他爹不在家，

孔子说，我化妆成我爹的样子，

去给人家上课行不行，

孔子不会他爹的课程，

他只会讲论语。

行，那本来找你爹的，那你就讲论语吧。

 

8.instanceof关键词

我们可以通过instanceof关键字来判断某个对象是否属于某种数据类型。如学生的对象属于学生类，学生的对象也属于人类。

在多态的情况下，因为会将父类声明为子类，当程序复杂度增加到一定量时，往往分不清，声明的是什么子类，而instanceof关键词可以帮助我们判断，基本格式举例为：

Person p = new Teacher（）；//多态

boolean trueorfalse = p instanceof Student；

这时返回的trueorfalse值为false。

 这个例子也叫“向上转型”，子类提升为了父类类型。

可以调用子类和父类的共有类型，但不能调用子类的特有成员。

 

还有向下转型

由父类类型强制转为子类类型，举例格式：

Fu f = new ErZi（）；

 ErZi z = ( ErZi)f;

好处：可以调用子类特有得1功能。

 

可以理解为：

孔子还喜欢打游戏，

孔子爹不会，打游戏不好。

但孔子爹还是觉得陪孩子打游戏可以正确引导他。

但是他不会，

孔子爹强行抓起游戏手柄一顿瞎按。

坑是一回事，也能玩嘛。

 9.0 this的第二种用法

package cn.itcast.demo03;
/*
 *   this可以在构造方法之间进行调用
 *   this.的方式,区分局部变量和成员变量同名情况
 *   this在构造方法之间的调用,语法 this()
 */
public class Person {
    private String name;
    private int age;
    
    public Person(){
        //调用了有参数的构造方法
        //参数李四,20传递给了变量name,age
        this("李四",20);
    }
    /*
     *  构造方法,传递String,int
     *  在创建对象的同时为成员变量赋值
     */
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
    
}

 

10.0 super的用法，具体看代码：

//定义Person类，将Student和Worker共性抽取出来
class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        // super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
class Student extends Person {
    // Student类的构造方法
    Student(String name, int age) {
        // 使用super关键字调用父类构造方法，进行相应的初始化动作
        super(name, age);
    }
    public void study() {// Studnet中特有的方法
        System.out.println(this.getName() + "同学在学习");
    }
}
class Worker extends Person {
    Worker(String name, int age) {
        // 使用super关键字调用父类构造方法，进行相应的初始化动作
        super(name, age);
    }
    public void work() {// Worker 中特有的方法
        System.out.println(this.getName() + "工人在工作");
    }
}
public class Test {
    public static void main(String[] args) {
        Student stu = new Student("小明",23);
stu.study();
        
Worker w = new Worker("小李",45);
w.work();
    }
}