java基础·小白入门（三）

最新推荐文章于 2024-10-06 20:16:20 发布

代码能跑就可以

最新推荐文章于 2024-10-06 20:16:20 发布

阅读量953

点赞数 23

文章标签： java python 开发语言笔记学习

本文链接：https://blog.csdn.net/s13352784013/article/details/139809168

版权

类的继承

基本概念

继承是一种由已有的类创建新类的机制。
在Java中，通过关键字extends继承一个已有的类，被继承的类称为父类（超类，基类），新的类称为子类（派生类）。
子类继承父类的全部属性和行为，并可以根据需要增加自己新的属性和行为。
Java不支持多继承（子类只能有一个父类）。
构造方法的继承：每个子类构造方法的第一条语句，都是隐含地调用super()，即父类无参构造方法。若要调用父类带参构造方法，可显式调用super(参数); 该句必须放第一行。
在子类中访问父类的成员：访问父类变量：super.变量名；访问父类方法：super.方法名。

方法覆盖

覆盖与重载相似，均是Java“多态性”的体现。
覆盖是指在子类中，定义名称、参数个数与类型、返回类型均与父类完全相同的方法，用来重写父类里同名方法的功能。
覆盖发生在子类与父类之间（方法头完全相同）。而重载是指在同一个类里定义名称相同，参数不同的方法。
在子类中覆盖方法时，可扩大父类中的方法访问权限，但不能缩小其权限。
final成员与final类：final关键字可用于定义常量。final关键字修饰方法时，父类的方法不会被子类覆盖。final关键字修饰类时，final类无法再派生其他子类，通常称为“最终类”。
用父类的引用变量访问子类成员：只限于“覆盖”的情况发生，访问到的是子类方法。如果用父类的引用变量访问子类成员的新方法（该方法父类没有），则会出现编译错误。

// 格式：父类 对象名 ＝ new 子类(); 对象名.子类方法;

// 方法举例
class Parent {
    void display() {
        System.out.println("父类方法");
    }
}

class Child extends Parent {
    @Override
    void display() {  // 方法覆盖
        System.out.println("子类方法");
    }

    void specificMethod() {
        System.out.println("子类特殊方法");
    }
}

public class Main {
    public static void main(String[] args) {
        Parent obj = new Child();  // 
        // 访问的是子类的覆盖方法
        obj.display(); // 输出：子类方法
        // 不能访问子类特有的方法
        // obj.specificMethod(); // 报错
    }
}

Object类

Object类是万类之父，所有的类均直接或间接继承于它。
如果一个类没有从别的类继承而来，即：无extends关键字，则该类默认为java.lang.Object类的子类。
举例：Object类中的equals 方法。equals 方法在 Object 类中定义，默认实现是比较对象的内存地址（即是否是同一个对象）这一点和==类似，== 运算符比较的是两个对象的内存地址，即它们是否引用同一个对象。。但是许多类（如 String、Integer、List 等）会覆盖 equals 方法，以便根据对象的内容进行比较。例如，String 类中的 equals 方法被覆盖为按内容比较两个字符串是否相等。
toString()方法的使用。toString()方法的功能是将对象的内容转换成字符串，并返回该字符串。若a是类A的对象，当对象a作为println()的参数时，Java会先用对象a来调用toString()方法，再把结果作为println()的参数输出。

System.out.println(a);
// 相当于：
System.out.println(a.toString());//将a转换成字符串，再由println()输出
// 如果没有重写toString方法，将使用 `Object` 类中的默认实现。结果类似：A@6b97fd

// 覆盖Object类的toString()方法举例
class A { 
   private  int  num;
   public A(int a){num=a;}
   public  String toString() {         //覆盖toString()方法
	   String str=" toString() called,num="+num;
	   return  str;
     }
}
public class Example {
	public static void main(String  args[]) {
		 A a = new A(2); 	
		 System.out.println(a.toString());  // 结果：toString() called,num=2
	}
}

getClass()方法的使用。如果想知道某个对象obj是属于哪个类时，可用obj.getClass()来查询。例：Class ca=a.getClass();这里用变量a调用getClass()方法。
对象运算符instanceof：可利用对象运算符instanceof来测试一个指定对象是否是指定类或它的子类的实例，若是，则返回true，否则返回false。

抽象类

创建抽象类的目的：为它派生出的一整组类做一个顶层设计。其作用类似“模板”，目的是根据它的格式来创建子类。
抽象类无法实例化，即不能用new运算符来创建实例对象。它只能被继承。
在类中没有方法体的方法，就是抽象方法。抽象方法必须加关键字abstract。
如果一个类中至少含有一个抽象方法，则为抽象类。抽象类必须在class前加上abstract关键字修饰。
抽象类的子类必须实现父类中的所有抽象方法，否则它也是抽象类。
可以将一个没有任何抽象方法的类声明为abstract，避免由这个类生成任何对象。

// 定义一个抽象类 Animal
abstract class Animal {
    // 抽象方法
    abstract void makeSound();
}
// Dog 类继承自 Animal
class Dog extends Animal {
    void makeSound() {
        System.out.println("汪汪");
    }
}
// Cat 类继承自 Animal
class Cat extends Animal {
    void makeSound() {
        System.out.println("喵喵");
    }
}

public class Main {
    public static void main(String[] args) {
        var myDog = new Dog();
        var myCat = new Cat();

        myDog.makeSound();
        myCat.makeSound();
    }
}

接口

接口中所有的方法都默认为public abstract。
接口中可以有数据成员，这些数据成员默认都是public static final，必须赋初值。所以接口中定义的变量都是常量，可以实现不同类之间常量共享。
接口的修饰符可以是public或abstract，其中abstract在缺省时也有效。为了在不同包之间互访接口，故接口常定义为public。
和public类一样，public接口也必须定义在与接口同名的文件中。
接口也具有继承性，一个接口可以继承自另一个接口。使用extends关键字定义一个接口是某个已存在的父接口的子接口，它将继承父接口的所有属性和方法。
一个类可以通过关键字implements实现接口。如果一个类既要继承父类，又要实现接口，则需注意先后顺序：extends必须放在implements前面。
Java中不允许类的多继承，但允许接口的多继承。
一个类只能有一个直接父类，但是它可以同时实现若干个接口。一个类实现多个接口时，在implements子句中用逗号分隔各个接口名。

interface Math
{
	double PI=3.1415926;	
}
class Arithmetic implements Math
{
	double roundArea(double radius)
	{
		return PI*radius*radius;		
	}
}
class Student
{
	public static void main(String[] args)
	{
		Arithmetic a=new Arithmetic();
		System.out.println(a.roundArea(3));
		System.out.println(Math.PI);  // 结果为：3.1415926		
		System.out.println(Arithmetic.PI);  // 结果为：3.1415926
		System.out.println(a.PI);  // 结果为：3.1415926
	}
}

// 接口的继承
interface Sittable
{
	void sit();
}
interface Lie
{
	void sleep();
}
interface Chair extends Sittable  // 单继承
{
}
interface Sofa extends Sittable, Lie  // 多继承
{
}

接口中的默认方法用default修饰符来定义，默认方法可以被子接口或被该接口的实现类所继承。子接口或实现类中若定义名称相同的默认方法，则父接口中的默认方法被隐藏。默认方法default有利于接口进化，和避免代码冗余。
接口中可以定义静态方法使用static关键字，默认的访问修饰符是public。该静态方法不能被子接口继承，也不能被实现类继承。接口的静态方法使用“接口名.方法名()”的形式访问。
可以在接口中定义私有方法。私有方法通常实现某种行为，这些行为可以被默认方法调用。

冲突问题：

如果子接口中定义了与父接口同名的常量或同名的方法，则父接口中的常量被隐藏，方法被覆盖。
对于常量，如果多个父接口中有同名的常量，则子接口不能继承，但子接口中可以定义一个同名的常量。
对于多个父接口中存在同名的方法时，可以用委托方式解决：接口名.super.方法名();

枚举和包

枚举

枚举类型是一种特殊的引用类型，它的声明和使用与类和接口类似。声明使用enum关键字。
枚举成员默认被final public static修饰。
枚举类型都隐含地继承了java.lang.Enum抽象类，Enum类又是Object类的子类，同时实现了Comparable<T>接口。
在枚举类型的声明中，除了枚举常量外还可以声明构造方法，成员变量和其他方法。

public enum Direction{
	EAST, SOUTH, WEST, NORTH;
}

包

为了便于管理大型软件系统中数目众多的类，解决类命名冲突的问题，Java引入了包（package）。
在程序中可以创建自己的包。格式：package 包名；
package语句必须是文件中的第一条语句。也就是说，在package语句之前，除了空白和注释之外不能有任何语句。
一个源程序文件通常称为一个编译单元（compile unit）。每个编译单元可以包含一个package语句、多个import语句以及类、接口和枚举定义。
一个编译单元中最多只能定义一个public类（或接口、枚举等），并且文件名与该public类名或接口名或枚举名相同。
如何取包名：建议将域名反转过来，中间用点号分隔作为包的名称，因为域名是全球唯一的，以这种方式定义的包名也是全球唯一的。假设一个域名为xy.boda.com，那么创建的包名可以为com.boda.xy，创建的类都存放在这个包下，这些类就不会与任何人的类冲突。