学习笔记07——Java基础（三）

已于 2022-04-07 10:56:21 修改
阅读量334 收藏 1
点赞数
文章标签： java
于 2022-04-05 21:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_52248951/article/details/123968787
版权

正则表达式，IO还有异常那块等周末有时间再整理，发现那块挺不好整理的。今天整理一下Java面向对象的一些特性。

一、类之间的关系

类之间的关系有三种：

  • 泛化（继承  实现）         A is a B
  • 包含（组合 聚合 关联）  A has a B
  • 依赖  (依赖)                     A ues a B

1、继承

  • 子类继承父类，通过一个关键字  extends。
  • 子类的对象可以调用父类中的(public protected)属性和方法当自己的使用。
  • 子类中可以有自己独有的属性或方法。
  • 子类可以重写父类中的方法。
  • 每一个类都有继承，不写extends关键字，默认继承Object类。
  • Java中继承是单个存在的（单继承)，每一个类只能有一个继承类（extends后面只能跟一个类）。

方法重写与方法重载的区别

方法重写方法重载
类具有继承关系的两个类一个类中
权限子类可以大于父类没有要求
特征

final  static  abstract 

父类是final的子类不能重写，

父类是static的子类不存在重写，

父类是abstact的子类必须重写，

否则子类也得是抽象的

 没有要求
返回值子类可以小于父类没有要求
方法名子类必须与父类一致 几个构成重载的方法名必须一致
参数子类必须与父类一致几个方法的参数必须不一致（个数，类型，顺序）
异常

编译时  运行时   

如果父类抛出运行时异常 子类可以不予理会

如果父类抛出的是编译时异常

*子类抛出异常的个数要少于等于父类

*子类抛出的异常类型要小于等于父类

 没有要求
方法体通常方法体执行与父类不一致通常几个方法之间执行不同的操作

this和super的使用

  • this指代当前执行方法时的那个对象，不一定是当前类对象。
  • super指代当前执行方法的对象的父类对象，空间内部的那个。
  • 它们都能调用一般属性和一般方法，可以放在类成员的任意位置上（属性，方法，构造方法，程序块）。

*注意：this和super在构造方法中调用另一个类的构造方法不能同时出现在第一行，一般方法可来回调用，写法上允许，编译也能通过，但可能出现运行时异常，构造方法不能来回调用，编译时就通不过。

2、包含

  • 组合：整体和部分的关系不可分割，如人和心脏的关系。
  • 聚合：整体和部分的关系，创建时有可能是分开的，如汽车与轮子的关系。
  • 关联：整体和部分的关系，可以分割，后来形成在一起，如人有汽车这种关系。

3、依赖

它不是整体和部分的关系，而是因为某一件事情产生了关系，临时组合在一起，这件事情一旦做完关系即解散。如农夫杀猪，农夫做这件事情需要一头猪。

在Java中的体现形式是：一个类的方法中使用到了另一个类的对象，这个类可以作为参数在方法中传递，也可以在方法中自己创建来用到的这个类。

二、抽象类与接口

1、抽象类

（1）抽象类

  • 用abstract关键字修饰。
  • 在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
  • 抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。
  • 由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。
  • 父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。
  • 在 Java 中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。
  • 继承抽象类用关键字extends。

举例

//Employee.java 
public abstract class Employee
{
   private String name;
   public Employee(String name)
   {
      System.out.println("Constructing an Employee");
      this.name = name;
   }
}
//继承Employee
public class Salary extends Employee
{
   private double salary; //Salary自己的属性
   public Salary(String name, double salary)
   {
       super(name);
       setSalary(salary);
   }
   
   public double getSalary()
   {
       return salary;
   }
   public void setSalary(double newSalary)
   {
       if(newSalary >= 0.0)
       {
          salary = newSalary;
       }
   }
}

（2）抽象方法

  • Abstract 关键字同样可以用来声明抽象方法，抽象方法只包含一个方法名，而没有方法体。
  • 抽象方法没有定义，方法名后面直接跟一个分号，而不是花括号。
  • 声明抽象方法会造成以下两个结果：
  1. 如果一个类包含抽象方法，那么该类必须是抽象类。
  2. 任何子类必须重写父类的抽象方法，或者声明自身为抽象类。

注意：继承抽象方法的子类必须重写该方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该抽象方法，否则，从最初的父类到最终的子类都不能用来实例化对象。

public abstract class Employee
{
   private String name;
   
   public abstract double computePay();
}

public class Salary extends Employee
{
   private double salary; // Annual salary
  
   public double computePay()  //实现父类的抽象方法
   {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
}

（3）抽象类总结

  •  抽象类不能被实例化，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。
  • 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
  •  抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。
  • 构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。
  • 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。

2、接口

接口是抽象到极致的抽象类，即接口中的每个方法都是抽象的，只有用static和final修饰的变量。

（1）接口与类相似点

  • 一个接口可以有多个方法。
  • 接口文件保存在 .java 结尾的文件中，文件名使用接口名。
  • 接口的字节码文件保存在 .class 结尾的文件中。
  • 接口相应的字节码文件必须在与包名称相匹配的目录结构中。

（2）接口与类的区别

  • 接口不能用于实例化对象。
  • 接口没有构造方法。
  • 接口中所有的方法必须是抽象方法，Java 8 之后 接口中可以使用 default 关键字修饰的非抽象方法。
  • 接口不能包含成员变量，除了 static 和 final 变量。
  • 接口不是被类继承了，而是要被类实现。
  • 接口支持多继承。

（3）接口特性

  • 接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错），当声明一个接口的时候，不必使用abstract关键字。
  • 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误），声明时同样不需要abstract关键字。
  • 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法，且接口中的方法都是公有的。

（4）抽象类和接口的区别

  • 1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
  • 2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
  • 3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
  • 4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

（5）接口的声明

重写接口声明时注意以下规则：

  • 类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常。
  • 类在重写方法时要保持一致的方法名，并且应该保持相同或者相兼容的返回值类型。
  • 如果实现接口的类是抽象类，那么就没必要实现该接口的方法。

[可见度] interface 接口名称 [extends 其他的接口名] {

    // 声明变量

    // 抽象方法

}

可见度：public abstract

/* 文件名 : Animal.java */
interface Animal {
   public void eat();
   public void travel();
}

（6）接口的实现

  • 一个类可以同时实现多个接口。
  • 一个类只能继承一个类，但是能实现多个接口。
  • 一个接口能继承另一个接口，这和类之间的继承比较相似。

当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类。

类使用implements关键字实现接口。在类声明中，Implements关键字放在class声明后面。

实现一个接口的语法，可以使用这个公式：

...implements 接口名称[, 其他接口名称, 其他接口名称..., ...] ...

/* 文件名 : MammalInt.java */
public class MammalInt implements Animal{
 
   public void eat(){
      System.out.println("Mammal eats");
   }
 
   public void travel(){
      System.out.println("Mammal travels");
   } 
 
   public int noOfLegs(){
      return 0;
   }
 
   public static void main(String args[]){
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
}

运行结果：
Mammal eats
Mammal travels

（7）接口的继承

  • 单继承：接口的继承使用extends关键字，子接口继承父接口的方法。
  • 多继承：在接口的多继承中extends关键字只需要使用一次，在其后跟着继承接口。 
//  Sports接口
public interface Sports
{
   public void setHomeTeam(String name);
   public void setVisitingTeam(String name);
}
//  Sports接口
public interface Event
{
   public void endOfQuarter(int quarter);
}
 
// 单继承
public interface Football extends Sports
{
   public void homeTeamScored(int points);
   public void visitingTeamScored(int points);
   public void endOfQuarter(int quarter);
}
//多继承
public interface Hockey extends Sports, Event
{
   public void homeTeamScored(int points);
   public void visitingTeamScored(int points);
   public void endOfQuarter(int quarter);
}

（8）标记接口

最常用的继承接口是没有包含任何方法的接口。

标记接口是没有任何方法和属性的接口.它仅仅表明它的类属于一个特定的类型,供其他代码来测试允许做一些事情。

package java.util;
public interface EventListener
{}

标记接口作用：

  • 建立一个公共的父接口：

    正如EventListener接口，这是由几十个其他接口扩展的Java API，你可以使用一个标记接口来建立一组接口的父接口。例如：当一个接口继承了EventListener接口，Java虚拟机(JVM)就知道该接口将要被用于一个事件的代理方案。

  • 向一个类添加数据类型：

    这种情况是标记接口最初的目的，实现标记接口的类不需要定义任何接口方法(因为标记接口根本就没有方法)，但是该类通过多态性变成一个接口类型。

简单形象的说就是给某个对象打个标（盖个戳），使对象拥有某个或某些特权。

三、封装、继承与多态

1、封装

在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。

封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。要访问该类的代码和数据，必须通过严格的接口控制。

封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。

适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

封装最常见的例子就是平时写domain实体类时，私有属性加公共方法。

（1）封装的优点

  • 1. 良好的封装能够减少耦合。

  • 2. 类内部的结构可以自由修改。

  • 3. 可以对成员变量进行更精确的控制。

  • 4. 隐藏信息，实现细节。

（2）Java封装的步骤

  1. 修改属性的可见性来限制对属性的访问（一般限制为private）。
  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;
    }
}

采用 this 关键字是为了解决实例变量（private String name）和局部变量（setName(String name)中的name变量）之间发生的同名的冲突。

2、继承

继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。

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

继承可提高代码的复用性与可维护性。

Java不支持多继承

（1）继承的特性

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

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

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

  • Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。

  • 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

（2）继承关键字

继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类。

  • extends关键字

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

public class Animal { 
    private String name;   
    private int id; 
    public Animal(String myName, int myid) { 
        //初始化属性值
    } 
    public void eat() {  //吃东西方法的具体实现  } 
    public void sleep() { //睡觉方法的具体实现  } 
} 
 
public class Penguin  extends  Animal{ 
}
  • implements关键字

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

public interface A {
    public void eat();
    public void sleep();
}
 
public interface B {
    public void show();
}
 
public class C implements A,B {
}

（3）supper与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 调用父类方法
  }
}
 
public class Test {
  public static void main(String[] args) {
    Animal a = new Animal();
    a.eat();
    Dog d = new Dog();
    d.eatTest();
  }
}

输出结果：
animal : eat
dog : eat
animal : eat

（4）final关键字

final 可以用来修饰变量（包括类属性、对象属性、局部变量和形参）、方法（包括类方法和对象方法）和类。final 含义为 "最终的"。

使用 final 关键字声明类，就是把类定义定义为最终类，不能被继承，或者用于修饰方法，该方法不能被子类重写。

  • 声明类：

    final class 类名 {//类体}

  • 声明方法：

    修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

（5）构造器

子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。

如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。

class SuperClass {
  private int n;
  SuperClass(){
    System.out.println("SuperClass()");
  }
  SuperClass(int n) {
    System.out.println("SuperClass(int n)");
    this.n = n;
  }
}
// SubClass 类继承
class SubClass extends SuperClass{
  private int n;
  
  SubClass(){ // 自动调用父类的无参数构造器
    System.out.println("SubClass");
  }  
  
  public SubClass(int n){ 
    super(300);  // 调用父类中带有参数的构造器
    System.out.println("SubClass(int n):"+n);
    this.n = n;
  }
}
public class TestSuperSub{
  public static void main (String args[]){
    System.out.println("------SubClass 类继承------");
    SubClass sc1 = new SubClass();
    SubClass sc2 = new SubClass(100); 
  }
}

输出结果：
------SubClass 类继承------
SuperClass()
SubClass
SuperClass(int n)
SubClass(int n):100

3、多态

多态是同一个行为具有多个不同表现形式或形态的能力。

多态就是同一个接口，使用不同的实例而执行不同操作。

同一个事件发生在不同的对象上会产生不同的结果。

（1）多态的优点

  • 1. 消除类型之间的耦合关系
  • 2. 可替换性
  • 3. 可扩充性
  • 4. 接口性
  • 5. 灵活性
  • 6. 简化性

（2）多态存在的三个必要条件

  • 继承
  • 重写
  • 父类引用指向子类对象：Parent p = new Child();

public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 对象调用 show 方法
      show(new Dog());  // 以 Dog 对象调用 show 方法
                
      Animal a = new Cat();  // 向上转型  
      a.eat();               // 调用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下转型  
      c.work();        // 调用的是 Cat 的 work
  }  
            
    public static void show(Animal a)  {
      a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

输出结果：
吃鱼
抓老鼠
吃骨头
看家
吃鱼
抓老鼠

（3）多态的实现方式

  • 重写
  • 接口
  • 抽象类与重写方法

（4）上转型与下转型

  • 上转型：把子类的对象交给父类去引用。上转型得来的父类对象只能使用父类中存在的方法，如果子类重写了这个方法，那就是调用子类的方法
  • 下转型：父类对象强转成子类对象。相当于重新new了一个子类对象，不是上转型得来的对象不能下转型。

四、枚举与包

1、枚举

（1）枚举的定义

Java 枚举是一个特殊的类，一般表示一组常量，枚举类使用 enum 关键字来定义，各个常量使用逗号 , 来分割。可在内部类、for循环，switch中使用。

enum Color
{
    RED, GREEN, BLUE;
}
 
public class Test
{
    // 执行输出结果
    public static void main(String[] args)
    {
        Color c1 = Color.RED;
        System.out.println(c1);

        for (Color myVar : Color.values()) {
           System.out.println(myVar);
        }

        Color myVar = Color.BLUE;

        switch(myVar) {
          case RED:
            System.out.println("红色");
            break;
          case GREEN:
            System.out.println("绿色");
            break;
          case BLUE:
            System.out.println("蓝色");
            break;
        }
    }
}

输出结果：
RED
RED
GREEN
BLUE
蓝色

（2）values(), ordinal() 和 valueOf() 方法

enum 定义的枚举类默认继承了 java.lang.Enum 类，并实现了 java.lang.Serializable 和 java.lang.Comparable 两个接口。

values(), ordinal() 和 valueOf() 方法位于 java.lang.Enum 类中：

  • values() 返回枚举类中所有的值。
  • ordinal()方法可以找到每个枚举常量的索引，就像数组索引一样。
  • valueOf()方法返回指定字符串值的枚举常量。
enum Color
{
    RED, GREEN, BLUE;
}
 
public class Test
{
    public static void main(String[] args)
    {
        // 调用 values()
        Color[] arr = Color.values();
 
        // 迭代枚举
        for (Color col : arr)
        {
            // 查看索引
            System.out.println(col + " at index " + col.ordinal());
        }
 
        // 使用 valueOf() 返回枚举常量，不存在的会报错 IllegalArgumentException
        System.out.println(Color.valueOf("RED"));
        // System.out.println(Color.valueOf("WHITE"));
    }
}

输出结果：
RED at index 0
GREEN at index 1
BLUE at index 2
RED

（3）枚举类成员

枚举跟普通类一样可以用自己的变量、方法和构造函数，构造函数只能使用 private 访问修饰符，所以外部无法调用。

枚举既可以包含具体方法，也可以包含抽象方法。 如果枚举类具有抽象方法，则枚举类的每个实例都必须实现它。

enum Color
{
    RED, GREEN, BLUE;
 
    // 构造函数
    private Color()
    {
        System.out.println("Constructor called for : " + this.toString());
    }
 
    public void colorInfo()
    {
        System.out.println("Universal Color");
    }
}
 
public class Test
{    
    // 输出
    public static void main(String[] args)
    {
        Color c1 = Color.RED;
        System.out.println(c1);
        c1.colorInfo();
    }
}
输出结果：
Constructor called for : RED
Constructor called for : GREEN
Constructor called for : BLUE
RED
Universal Color

2、package

（1）包的作用——防止命名冲突

  • 1、把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。

  • 2、如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。

  • 3、包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

（2）创建包

创建包的时候，你需要为这个包取一个合适的名字。之后，如果其他的一个源文件包含了这个包提供的类、接口、枚举或者注释类型的时候，都必须将这个包的声明放在这个源文件的开头。

包声明应该在源文件的第一行，每个源文件只能有一个包声明，这个文件中的每个类型都应用于它。

如果一个源文件中没有使用包声明，那么其中的类，函数，枚举，注释等将被放在一个无名的包（unnamed package）中。

（3）import关键字

为了能够使用某一个包的成员，我们需要在 Java 程序中明确导入该包。使用 "import" 语句可完成此功能。

在 java 源文件中 import 语句应位于 package 语句之后，所有类的定义之前，可以没有，也可以有多条，其语法格式为：

import package1[.package2…].(classname|*);

如果在一个包中，一个类想要使用本包中的另一个类，那么该包名可以省略。

（4）package目录结构

类放在包中会有两种主要的结果：

  • 包名成为类名的一部分，正如我们前面讨论的一样。
  • 包名必须与相应的字节码所在的目录结构相吻合。
是光颜鸭
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值