java——继承与多态——重点部分总结****************************************************************...

深碍√TFBOYSˉ_ 2024-04-01 18:20 66阅读 0赞

**Java类名**必须是由一个或多个有意义的单词连缀而成的，每个单词首字母大写，其他字母全部小写，单词与单词之间不要使用任何分

**成员变量名**：成员变量名只要是一个合法的标识符即可，建议成员变量名应该由一个或多个有意义的单词连缀而成，第一个单词首字母小写，后面每个单词首字母大写，其他字母全部小写，单词与单词之间不要使用任何分隔符。

**方法名**：方法名的命名规则与成员变量的命名规则基本相同，但由于方法用于描述该类或该类的实例的行为特征或功能实现，因此通常建议方法名以英文动词开头。

方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。

(1)方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载(Overloading)。

(2)方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写(Overriding)。

(3)方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。

**继承的特性**

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

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

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

================================================================================================================

=================================================================================================================

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

**多态存在的三个必要条件**

继承

重写

父类引用指向子类对象：**Parent p = new Child();**

正常的继承关系中：

父子类继承关系着中：

1、子类可以拥有父类的变量；  
2、子类可以拥有父类的方法；

父子类继承关系中：

如果变量名重名，则创建子对象时，有2种访问方式：(等号左边是谁，则优先用谁，没有则向上找)

1、创建父类对象，则只能使用父类的变量，没有任何子类类容； Animal anl = new Animal();

2、创建子类对象，则访问的是子类中的变量； Cat ct = new Cat();

Cat ct = new Cat();

父类和子类中有相同的成员变量，则访问的是子类中的成员变量；

父类和子类中有相同的成员方法，则访问的是子类中的成员方法；

================================================================

多态： ——向上转型

Animal an = new Cat();

左边父亲，右边儿子的继承关系中： 父类引用指向子类对象(左父右子) 子类对象被当做父类使用。

格式：

父类名称 对象名 = new 子类名称()；

或者

接口名称 对象名 = new 实现类名称()；

成员变量：

父子类有相同成员变量时。(等号左边是谁，则优先用谁，没有则向上找) //访问的是父亲中的变量

父亲中有此变量，子类中没有有此变量， //访问的是父类中的变量

父亲中没有此变量，子类中有此变量， //则访问此变量时，报错。

成员方法：

父子类有相同方法时。new的是谁，就使用谁。 //父子都有，优先用子

父亲有单独方法，子类没有此方法时。可以访问父类特有方法。 //子类没有，父类有，则向上找到父类

父亲中没有此方法，子类有此方法时， //访问此方法时，报错

============================================================================

向下类型转换

Animal as = new Dog(); //向下类型转换，通过向下转型，解决了多态的弊端：不能访问子类中的特有方法。

Dog d2 = (Dog)as;

如果获取的是父类中有的变量(独一无二，子类中没有)，子类中没有， 则获取成功，获取父类的中的变量；

如果获取的是子类中有的变量(独一无二，父类中没有)，子类中有， 则获取成功；

父类中和子类中有相同变量，则显示子类变量

父类中和子类中有相同方法，则执行子类方法；

如果执行的是父类中的方法(独一无二，子类中没有)，则执行父类中的方法

如果执行的是子类中的方法(独一无二，父类中没有)，则执行子类中的方法

class Animal
    {
        public void move()
        {
            System.out.println("动物——可以移动——子类和父类同一个方法");
        }
    
        public void name()
        {
            System.out.println("动物——name——父类独有的方法");
        }
    }

class Dog extends Animal
    {
        public void move()
        {
            System.out.println("狗——可以跑和走——子类和父类同一个方法");
        }
    
        public void bark()
        {
            System.out.println("狗——可以叫——子类单独有的方法");
            super.move();
        }
    }
    
    public class TestDog
    {
        public static void main(String args[])
        {
    
            Animal b = new Dog();      //向上类型转换
            b.name();
            b.move();     //重写，父类和子类都有同名方法
    //        b.bark();   父类中没有这个方法，会使用报错
    
            System.out.println("+++++++++++++++++++++++++++");
    
            Dog d = new Dog();     //这个就是单纯的继承
            d.name();
            d.move();
            d.bark();
    
            System.out.println("------------------------------");
    
            Animal as = new Dog();     //向下类型转换，通过向下转型，解决了多态的弊端：不能访问子类中的特有方法。
            Dog d2 = (Dog)as;
    
            d2.name();
            d2.move();
            d2.bark();
    
            System.out.println("================================");
    
            as.name();
            as.move();
            ((Dog) as).bark();
    
        }
    }

public class Cat extends Animal
    {
        public String name = "Cat：猫";
        public String str = "Cat：可爱的小猫";
        public static String staticName = "Dog：我是喵星人";
    
        public void eat()
        {
            System.out.println("Cat：吃饭");
        }
    
        public static void staticEat()
        {
            System.out.println("Cat：猫在吃饭");
        }
    
        public void eatMethod()
        {
            System.out.println("Cat：猫喜欢吃鱼");
        }
    
        public static void main(String[] args)
        {
    
    //        Animal an = new Cat();     //向上类型转换 ,不能调用子类特有的成员变量以及方法
    //
    //        System.out.println(an.name99);
    //        System.out.println(an.name);
    //        an.eat();
    //
    //        System.out.println("-----------------------------------");
    //
    //        Cat ct = new Cat();             //继承
    //
    //        System.out.println(ct.name99);
    //        System.out.println(ct.name);
    //        System.out.println(ct.str);
    //        ct.eat();
    //        ct.eatMethod();
    //
    //        System.out.println("+++++++++++++++++++++++++++++++++++");
    
            Animal animal = new Cat();
            Cat cat = (Cat) animal;         // 向下转型
    
    //        System.out.println(animal.name); // 输出Animal类的name变量
    //        System.out.println(animal.staticName); // 输出Animal类的staticName变量
    
            System.out.println(cat.name99);
            System.out.println(cat.name);
            System.out.println(cat.str);
            cat.eat2();
            cat.eat();
            cat.eatMethod();
    
            System.out.println("=============================++++++++++++++++++++++++++");
    
            System.out.println(animal.name99);
            System.out.println(animal.name);
            animal.eat();
    
            ((Cat) animal).eatMethod();
            System.out.println(((Cat) animal).str);
    
    //        animal.eat(); // 输出Cat类的eat()方法
    //        animal.staticEat(); // 输出Animal类的staticEat()方法
    //        System.out.println(cat.str); // 调用Cat类的str变量
    //        cat.eatMethod(); // 调用Cat类的eatMethod()方法
        }
    }

=============================================================================================================

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。

父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。

在 Java 中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

======================================================================================================================

接口(英文：Interface)，在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。

接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。

另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

**接口与类的区别：**

接口不能用于实例化对象。

接口没有构造方法。

接口中所有的方法必须是抽象方法，Java 8 之后 接口中可以使用 default 关键字修饰的非抽象方法。

接口不能包含成员变量，除了 static 和 final 变量。

接口不是被类继承了，而是要被类实现。

接口支持多继承。

**接口特性**

接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 **public abstract**(只能是 public abstract，其他修饰符都会报错)。

接口中可以含有变量，但是接口中的变量会被隐式的指定为 **public static final** 变量(并且只能是 public，用 private 修饰会报编译错误)。

接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

**抽象类和接口的区别**

1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。

2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 **public static final** 类型的。

3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。

4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

================================================================================================================================

// 使用 new 指定数组大小后进行初始化

int\[\] number = new int\[5\];

number\[0\] = 1;

number\[1\] = 2;

number\[2\] = 3;

number\[3\] = 5;

number\[4\] = 8;

// 使用 new 指定数组元素的值(2种方式)

int\[\] number2 = new int\[\] \{ 1, 2, 3, 5, 8,9,10\};

// 直接指定数组元素的值(2种方式)

int\[\] number4 = \{ 1, 2, 3 \};

如果程序员只指定了数组的长度，那么系统将负责为这些数组元素分配初始值。指定初始值时，系统按如下规则分配初始值。

*  数组元素的类型是基本类型中的整数类型(byte、short、int 和 long)，则数组元素的值是 0。
 *  数组元素的类型是基本类型中的浮点类型(float、double)，则数组元素的值是 0.0。
 *  数组元素的类型是基本类型中的字符类型(char)，则数组元素的值是‘\\u0000’。
 *  数组元素的类型是基本类型中的布尔类型(boolean)，则数组元素的值是 false。
 *  数组元素的类型是引用类型(类、接口和数组)，则数组元素的值是 null。