Java学习笔记

目录

数据类型

对象构造过程，构造方法

方法的重载，重写覆盖

数组定义

封装、继承、多态

---

数据类型

• 内置数据类型

        八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

• 引用数据类型

        引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型。变量一旦声明后，类型就不能被改变了。

参考内容：https://www.runoob.com/java/java-basic-datatypes.html

对象构造过程，构造方法

        面向对象语言。支持以下基本概念：封装、继承、多态、抽象、类、对象、实例、方法、重载。

对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。

（对比现实对象和软件对象，软件对象也有状态和行为。软件对象的状态就是属性，行为通过方法体现。)

类：类是一个模板，它描述一类对象的行为和状态。

创建对象

        对象是根据类创建的。在Java中，使用关键字 new 来创建一个新的对象。创建对象需要以下三步：

• 声明：声明一个对象，包括对象名称和对象类型。
• 实例化：使用关键字 new 来创建一个对象。
• 初始化：使用 new 创建对象时，会调用构造方法初始化对象。

Puppy myPuppy = new Puppy( "tommy" );

构造方法

        每个类都有构造方法。如果没有显式地为类定义构造方法，Java 编译器将会为该类提供一个默认构造方法。

        在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。

public class Puppy{
    public Puppy(){
    }
    public Puppy(String name){
        // 这个构造器仅有一个参数：name
    }
}

参考内容：https://www.runoob.com/java/java-methods.html

方法的重载，重写覆盖

方法的重载

        一个类的两个方法拥有相同的名字，但是有不同的参数列表。

public static int max(int num1, int num2);

public static double max(double num1, double num2) ;

方法1：下面的方法包含 2 个参数 num1 和 num2，它返回这两个参数(整型)的最大值。

/** 返回两个整型变量数据的较大值 */
public static int max(int num1, int num2) {
   if (num1 > num2)
        return num1;
   else
        return num2;
}

方法2：返回这两个参数(浮点型)的最大值

public static double max(double num1, double num2) {
  if (num1 > num2)
    return num1;
  else
    return num2;
}

方法的重写(覆盖override)

        子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

重写条件：

1.子类的方法的形参列表，方法名称，要和父类方法的形参列表，方法名称完全一样。

2.子类方法的返回类型和父类的返回类型一样，或者是父类返回类型的子类。

3.子类方法不能小于父类的访问权限。

在面向对象原则里，重写意味着可以重写任何现有方法。实例如下：

class Animal{
   public void move(){
      System.out.println("动物可以移动");
   }
}
class Dog extends Animal{
   public void move(){
      System.out.println("狗可以跑和走");
   }
}

参考内容：https://www.runoob.com/java/java-override-overload.html 

数组定义

声明数组变量：dataType[] arrayRefVar;

创建数组：arrayRefVar = new dataType[arraySize];

数组变量的声明，和创建数组：dataType[] arrayRefVar = new dataType[arraySize];

参考内容：https://www.runoob.com/java/java-array.html

封装、继承、多态

1、封装

        封装是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问， 修改属性的可见性来限制对属性的访问（(private/protected)。

封装的步骤

1. 修改属性的可见性来限制对属性的访问（一般限制为private）

public class Person {
    private String name;
    private int age;
}

将 name 和 age 属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。 

2. 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问

 

public class Person{
    private String name;
    private int age;
​
    public int getAge(){
      return age;
    }
    public String getName(){
      return name;
    }
    public void setAge(int age){
      this.age = age;
    }
    public void setName(String name){
      this.name = name;
    }
}

public方法是外部类访问该类成员变量的入口。采用 this 关键字是为了解决实例变量（private String name）和局部变量（setName(String name)中的name变量）之间发生的同名的冲突。 

参考内容：https://www.runoob.com/java/java-encapsulation.html

2、继承

        继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为，子类会具有父类的一般特性也会具有自身的特性。

继承格式

        通过 extends 关键字可以申明一个类是从另外一个类继承而来的。

class 父类 {

}

class 子类 extends 父类 {

}

 

继承特性

• 子类拥有父类非 private 的属性、方法。

• 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

• 子类可以用自己的方式实现父类的方法。

• Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类

继承关键字 

extend：类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。

implements ：使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）（Java 不支持多继承，但支持多重继承)。

public class C implements A,B { }

super 与 this 关键字

super：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

this：指向自己的引用。

class Animal {
  void eat() {
    System.out.println("animal : eat");
  }
}
 
class Dog extends Animal {
  void eat() {
    System.out.println("dog : eat");
  }
  void eatTest() {
    this.eat();   // this 调用自己的方法
    super.eat();  // super 调用父类方法
  }
}

 参考内容：https://www.runoob.com/java/java-inheritance.html

3、多态

        同一个行为具有多个不同表现形式或形态的能力。同一个接口，使用不同的实例而执行不同操作。

参考内容：https://www.runoob.com/java/java-polymorphism.html