《JAVA学习笔记》之重载、覆盖、对象的上转型对象、访问权限、关键字、接口、多态、内部类、匿名类

最新推荐文章于 2021-08-12 18:50:25 发布

每天八杯水D

最新推荐文章于 2021-08-12 18:50:25 发布

阅读量174

点赞数

分类专栏： JAVA 文章标签： java 接口多态继承匿名类

本文链接：https://blog.csdn.net/weixin_45947938/article/details/115478081

版权

JAVA 专栏收录该内容

22 篇文章 1 订阅

订阅专栏

你这个年龄还能睡得着觉！！！

（五）、static、this关键字和 import语句

一、五周——主要内容：

• 类

• 对象

•参数传值

•对象组合：一个类把把其他类的对象作为自己的成员变量

•static关键字

•this关键字

•包（package）

•import语句

• jar文件：我们可以使用 jar.exe 命令把一些类的字节码文件压缩成一个 jar 文件，然后将这个 jar 文件存放到 Java 运行环境的扩展中，即将该 jar 文件存放在 JDK 安装目录的 jre\lib\ext 文件夹中。这样， Java 应用程序就可以使用这个 jar 文件中的类来创建对象了。

（一）、掌握如何创建类和构造对象

1、面向对象编程的三个特性：

◇封装性 :将数据和对数据的操作封装在一起；封装的实体=数据+方法；解决了数据的安全性问题。

◇继承：子类对父类属性、功能的继承；解决了代码的重用问题。

◇多态：操作名称多态；与继承相关的同一操作的多态；父类的方法可以被子类重写，产生各自的功能；解决了程序的扩展问题。

2、类介绍：

（1）、类概念

• 类是具有共同属性和行为的对象的抽象。

•类可以定义为数据和方法的集合。

•类也称为模板，因为它们提供了对象的基本框架。

（2）、类修饰

private、public、protected、final 相当于常量、static、abstract

（3）、类由成员变量和成员方法两部分组成

成员变量包括基本类型：整型、浮点型、字符型；引用类型：数组、对象和接口；修饰符：public \ private ，friendly \protected，static 类变量，final相当于常量
成员变量的其他叫法——实例变量与类（static）变量：在声明成员变量时，用关键字static给予修饰的称作类变量，否则称作实例变量（类变量也称为static变量，静态变量）。
成员方法就是函数，一个类中的方法可以互相调用
成员方法的其他叫法——实例方法与类（static）方法：方法声明时，方法类型前面不加关键字static修饰的是实例方法、加static修饰的是类方法（静态方法）。类方法只能对类变量进行操作。

3、对象介绍

对象声明和为对象new分配内存

（二）、掌握方法的重载和覆盖

方法重载的意思是：一个类中可以有多个方法具有相同的名字，但这些方法的参数必须不同，即或者是参数的个数不同，或者是参数的类型不同。

 class Area{

    float getArea(float r){
	return 3.14*r*r;
    }

    float getArea(float x,float y){
	return x*y;
    }

    float getArea(int x,float y){
	return x*y;
}

构造函数也可以重载！！！

（三）、了解包（package）概念

概念：包是 Java 语言中有效地管理类的一个机制。

作用： 用于将完全不同功能的类分门别类，放在不同的目录 ( 包 ) 下。包的命名规则：将公司的域名反转作为包名： www.xhu.edu.cn cn.edu.xhu( 包名 )，对于包名：每个字母都需要小写。包名的目的是有效的区分名字相同的类

（四）、访问权限

1） public（公共的）：被public所修饰的属性和方法可以被所有类访问。

2） protected（受保护的）：被protected所修饰的属性和方法可以在类内部、相同包以及该类的子类所访问。

3） private（私有的）：被private所修饰的属性和方法只能在该类内部使用

4）默认的（不加任何访问修饰符）：在类内部以及相同包下面的类所使用。

（五）、static、this关键字和 import语句

1、static——类(静态)变量和类(静态)方法——一个类的所有对象共享该类的类变量

注意：静态方法只能继承，不能重写

2、this——代表当前使用的对象；this可以修饰实例方法和构造方法，但不可以修饰类方法。

当实例成员变量在实例方法中出现时，默认的格式是：this.成员变量。

当static成员变量在实例方法中出现时，默认的格式是：类名.成员变量。

3、import——作用：用来引用不在同一个包里面的其他类的对象，一个类可能需要另一个类声明的对象作为自己的成员或方法中的局部变量，

二、五周——主要内容

子类与父类
子类的继承性
子类对象的构造过程
成员变量的隐藏和方法重写
super关键字
final关键字
对象的上转型对象
继承与多态
abstract类与abstract方法
接口

（一）、继承

1、介绍：Java是单继承的，意味着一个类只能从另一个类继承（被继承的类叫做父类【基类，base class】，继承的类叫做子类），Java中的继承使用extends关键字。

2、声明： public class Son extends Father——class 子类名 extends 父类名

3、子类与父类：

思考一、子类继承了什么？

子类继承父类的成员变量
子类继承父类的方法

思考二、访问权限对继承是否有影响？

如果子类和父类在同一个包中，那么，子类自然地继承了其父类中不是private的成员变量作为自己的成员变量，并且也自然地继承了父类中不是private的方法作为自己的方法，继承的成员变量或方法的访问权限保持不变。
如果子类和父类不在同一个包中，那么，子类继承了父类的protected、public成员变量做为子类的成员变量，并且继承了父类的protected、public方法为子类的方法，继承的成员或方法的访问权限保持不变。
以上两者区别在于友好的变量和方法必须在同一个包才能继承；
静态static方法只能继承，不能重写
子类不继承父类的构造方法，因此，子类如果想使用父类的构造方法，必须在子类的构造方法中使用，并且必须使用关键字super来表示，而且super必须是子类构造方法中的头一条语句。

4、成员变量的隐藏和方法重写

成员变量的隐藏（隐藏变量）——子类中声明的成员变量和父类中的成员变量同名时，子类就隐藏了继承的成员变量。

方法重写（隐藏方法）——子类中定义一个方法，这个方法的名字、参数个数、参数的类型和父类的方法完全相同。重写的目的：子类通过方法的重写可以隐藏继承的方法，

//建一个A类
class A{
    int num=0;   //成员变量，下面是B是子类，B里面声明一个同样的变量num，就会被隐藏
    public A(int i){   //成员方法        
        num=i;  
    }
}


//B继承A
class B extends A{ 
    int num=0;    //成员方法,与父类A相同的变量名字，即隐藏父类成员变量 
    public B(){       
        System.out.println("num= "+num); //这里变量num是类B的，因为A类的num被隐藏了 

        System.out.println("super.num= "+super.num);  }  //如果要使用被隐藏的父类变量num，需要使用super关键字
    }
}

方法重载和方法重写区别：重载发生在同一个类内部的两个或多个方法。重写发生在父类与子类之间。

（二）、super关键字

super表示对父类对象的引用。子类可以隐藏从父类继承的成员变量和方法，如果在子类中想使用被子类隐藏的成员变量或方法就可以使用关键字super。

作用：使用super操作被隐藏的成员变量和方法。

注意：当用子类的构造方法创建一个子类对象时，子类的构造方法总是先调用父类的某个构造方法，由于子类不能继承父类的构造方法，因此，子类在其构造方法中必须使用super关键字来调用父类的构造方法，而且super必须是子类构造方法中的头一条语句，默认的有super();

（三）、final关键字

修饰范围：final关键字可以修饰类、成员方法、成员变量和方法中的局部变量。此时变量是常量，常量是不可以再发生变化的。

注意：

final类不能被继承，即不能有子类。
如果用final修饰父类中的一个方法，那么这个方法不允许子类重写。
当final修饰一个原生数据类型时，表示该原生数据类型的值不能发生变化（比如说不能从10变为20）。
如果final修饰一个引用类型时，表示该引用类型不能再指向其他对象了，但该引用所指向的对象的内容是可以发生变化的。

作用：final关键字：final可以修饰属性、方法、类。

final修饰类：当一个类被final所修饰时，表示该类是一个终态类，即不能被继承。
final修饰方法：当一个方法被final所修饰时，表示该方法是一个终态方法，即不能被重写（Override）。
final修饰属性：当一个属性被final所修饰时，表示该属性不能被改写。

（四）、多态

概念：就是指父类的某个方法被其子类重写时，可以各自产生自己的功能行为。

核心技术：上转型对象

多态的实现：

（五）、对象的上转型对象

概念：一个子类的对象b赋值给其父类的对象a，父类对象a就是子类对象b的上转型对象。

A a;//A是父类   a是父类对象
B b=new B(); //B是子类  b是子类对象
a=b;  //子类对象赋值给父类对象  a在上面  所以称之为子类对象的上转型对象

（六）、abstract(抽象)关键字

面向抽象编程

修饰范围：类和方法如：abstract class A

abstract方法只允许声明，不允许实现（没有方法体，是空的），而且不允许使用final和abstract同时修饰；在设计程序时，经常会使用abstract类，因为设计者使用abstract类只关心操作，不用关心这些操作的具体实现的细节，可以使程序的设计者把主要精力放在设计上，将这些细节留给子类的设计者，避免设计者把大量的时间和精力花费在具体的算法上。

例如：下面是一个抽象类女朋友，设计者只需要设计女朋友的说话和厨艺，而具体说话怎么样和厨艺怎么样由自己去琢磨其中的细节。

abstract class GirlFriend(){   //抽象类，封装了两个行为标准
    abstract void speak();  //抽象方法：只声明 不实现
    abstract void cooking();
}

理解抽象类的核心思想：

抽象类可以抽象出重要的行为标准，该行为标准用抽象方法来表示。即抽象类封装了子类必须要有的行为标准。
抽象类声明的对象可以成为其子类的对象的上转型对象，调用子类重写的方法，即体现了子类根据抽象类里的行为标准给出的具体行为。

注意：abstract类不能用new运算创建对象，那么我们可以使用abstract类的子类的对象赋值给abstract类对象，即将abstract类声明对象作为其子类的上转型对象，那么这个上转型对象就可以调用子类重写的方法。

abstract类和接口的比较区别

（七）、接口（一种数据类型）

1、作用：为了克服Java单继承的缺点，Java使用了接口，一个类可以实现多个接口。一个类在自己类体里面使用关键字implement代表自己是接口

2、声明和定义：与类很相似；使用关键字interface。

接口声明： interface 接口的名字；

接口体：接口体中包含常量定义和方法定义两部分。接口里面所有的方法是抽象的abstract(即接口里面的方法只有声明没有实现)；接口体里面只有static常量没有变量；只有抽象方法没有普通方法；访问权限都是public

3、实现接口(如同抽象类的抽象方法被子类重写)：一个类通过在声明时使用 implement关键字声明自己实现一个或多个接口。

实现接口——其意思就是一个类把该接口里面的抽象方法重写一次来具体的实现。

注意：分为抽象abstract类和非抽象类实现接口两种方向，当非抽象类实现接口时该非抽象类必须重写这个接口中的方法（public修饰和给出方法体）；而抽象类既可以重写接口中的方法，也可以直接使用接口中的方法。

//接口声明
interface jk{

}

//A类实现接口jk
class A implement jk

//一个类也可以实现多个接口，用逗号隔开接口名
class A implement jk1,jk2;

如果父类实现了某个接口，那么子类也自然的实现了该接口，子类就不必再使用关键字implement声明实现这个接口了。
接口也可以被继承，通过关键字extends声明一个接口是另一个接口的子接口。子接口将继承父接口中的全部方法和常量。

4、通过import语句引入包中的接口 import java.io.*;

5、接口回调（如同抽象类使用上转型对象调用子类对象重写的方法）：可以把实现某一接口的类创建的对象的引用赋给该接口声明的接口变量中，接口变量中存放实现接口的类的对象的引用（即接口变量存放的是对象的地址），那么该接口变量就可以调用被类重写的接口方法。这样就可以实现同一个接口可以有不同的被重写的方法，使用接口回调时就可以各个对象使用各自重写的方法了。

6、理解接口：接口和抽象类一样也可以抽象出重要的行为标准，该行为标准用抽象方法来表示；和抽象类被自己的子类重写方法后再使用上转型对象反过来调用子类对象重写的方法一样，接口里面的抽象方法被类实现重写后再使用接口变量把对象的引用地址赋值给接口变量，这样接口变量就如同抽象类的上转型对象一样也可以调用被重写的方法了。

7、接口与多态：接口产生的多态就是指不同的类在实现同一个接口时可能具有不同的实现方式，那么接口变量在回调接口方法时就可能具有多种形态。

8、接口参数：一个方法的参数是接口类型，可以将任何实现该接口的类的实例对象的引用地址传递给该接口参数。

￥￥￥￥￥￥￥￥￥abstract类与接口具有相似的抽象多态编程思想￥￥￥￥￥￥￥￥￥

比较如下：

abstract类和接口都可以有abstract方法
接口中只可以有常量，不能有变量；而abstract类中都可以有
abstract类中可以有非abstract方法；而接口只能是abstract方法

何时使用abstract类何时使用接口？？？

使用abstract类的场景：当子类需要从父类继承一些变量或一些重要的非abstract方法时使用abstract类——面向抽象编程。
使用接口的场景：当子类不需要继承，只是需要若干类重写的abstract方法的具体细节时使用接口——面向接口编程。

三、六周——主要内容

内部类
异常类
匿名类
断言
Class类

（一）、内部类

概念：一个类中定义另一个类，这样的类称作内部类。而包含内部类的类称做内部类的外嵌类；内部类的字节码文件名字：外嵌类名$内部类名

内部类与外嵌类的关系：

内部类可以调用外嵌类的成员变量和成员方法。
内部类不可以使用static类变量和类方法。
外嵌类可以使用内部类声明对象，作为外嵌类的成员。

作用：隐藏内部细节，不想让人访问，安全封装。

如果内部类是private，则不能被其他类所访问。但可以通过接口或抽象类来进行访问。这样内部类就实现了封装思想。
一个内部类对象可以访问创建它的外部类对象的内容，甚至包括私有变量！

内部类好处：

体现了封装的思想（很好的隐藏了类实现的细节）；当我们需要在某一情形下实现一个接口，而在另一情形下又不需要实现这个接口时，我们可以使用内部类来解决这一问题。让内部类来实现这个接口。
与接口相结合，而java通过内部类加上接口，可以解决了JAVA中无法实现多继承的问题。

注意：内部类可以使用static声明，使用之后内部类就是外嵌类的一种静态数据类型，这样其他类就也可以使用static内部类来创建对象了，但是此时static内部类不能操作外嵌类的实例成员变量。

（二）、异常类

所谓异常– 就是程序运行时可能出现一些错误，比如试图打开一个根本不存在的文件等，异常处理将会改变程序的控制流程，让程序有机会对错误作出处理。

Java使用try~catch语句来处理异常，将可能出现的异常操作放在try~catch语句的try部分，将发生异常后的处理放在catch部分。

try~catch语句的格式如下：

 try {

      包含可能发生异常的语句

  }

 catch(ExceptionSubClass1  e) {

    …发生异常后的处理

 }

 catch(ExceptionSubClass2  e) {

    …发生异常后的处理

 }

我们也可以扩展Exception类定义自己的异常类，然后规定哪些方法产生这样的异常。一个方法在声明时可以使用throws关键字声明要产生的若干个异常，并在该方法的方法体中具体给出产生异常的操作，即用相应的异常类创建对象，并使用throw关键字抛出该异常对象，导致该方法结束执行。

（三）、匿名类

作用：使用类体创建一个子类对象（一共两种创建子类对象的方法，匿名类是一种；父类的构造方法也是创建子类对象的方法）

因为匿名类是在类中使用来创建子类的对象的，所以匿名类也是内部类；匿名类相当于就是一个子类，匿名类的类体中是父类的方法，但是需要匿名类重写方法；

称为匿名类的原因：因为该子类没有明显的用类声明来定义；

1、和类有关的匿名类

Java允许我们直接使用一个类的子类的类体创建一个子类对象。
创建子类对象时，除了使用父类的构造方法外还有类体，此类体被认为是一个子类去掉类声明后的类体，称作匿名类。
假设People是类，那么下列代码就是用People的一个子类（匿名类）创建对象：new People () {匿名类的类体}; = 一个子类的对象

2、和接口有关的匿名类

假设Computable是一个接口，那么，Java允许直接用接口名和一个类体创建一个匿名对象，此类体被认为是实现了Computable接口的类去掉类声明后的类体，称作匿名类。
下列代码就是用实现了Computable接口的类（匿名类）创建对象： new Computable(){实现接口的匿名类的类体 }