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

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

• 1 public class Student {
  2     public String name;
  3     public int age;
  4     
  5     public void study(){
  6         System.out.println("学生学习");
  7     }
  8 }

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

• 1 public class UnStudent extends Student{
  2     public void study(){
  3         System.out.println("大学生的学习方法");
  4     }
  5     public void playGame(){
  6         System.out.println("大学生玩dota");
  7     }
  8 }

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

•  1 public class Test {
   2     public static void main(String[] args) {    
   3         //自动转型
   4         UnStudent us = new UnStudent();
   5         Student us1 = new UnStudent();
   6         Student us2 = new Student();
   7         
   8         us.study();
   9         us1.study();
  10         us2.study();
  11         
  12         us.playGame();
  13         us1.playGame();
  14         us2.playGame();
  15     }
  16 }

  • 在上文中主函数里大学生（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. 接口和抽象类有什么用？
   1. 接口和抽象类的作用是用来当父类被继承的，抽象方法是用来指导子类重写(实现)的
   2. 关键子：implements
   3. 格式：
      • public class 子类类名  implements 接口名{
          //重写父类的所有的抽象方法
         }
   4. 接口无非就是领导，只是指导开发
5. 文件名：Teacher.java

    1 public interface Teacher {
    2     public static final String name = "aa";
    3     public static final String job = "aa";
    4     public static final int age = 20;
    5     
    6     //抽象方法
    7     public abstract void play1();
    8     public abstract void play2();
    9     public abstract void play3();
   10     public abstract void play4();
   11     public abstract void play5();
   12 }

6. 文件名：UnTeacehr.java

   1 public abstract class UnTeacher implements Teacher{
   2     
   3 }

    

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