Java基础总结(二)

1.    封装

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问

 

 2.   包（package）

1.对类文件进行分类管理。

2.给类提供多层命名空间。

3.写在程序文件的第一行。

4.类名的全称是：包名.类名

5.包也是一种封装的形式。

 

总结：

1.包与包之间进行访问，被访问的包中的类以及类中的成员，需要public修饰。

2.不同包中的子类还可以直接访问父类中被protected权限修饰的成员。

3.包与包之间可以使用的权限只有两种：public，protected。

 

                    public    protected   default   private

同一个类中         ok        ok             ok          ok

同一个包中         ok        ok             ok

子类                 ok        ok

不同的包中         ok

类的成员不写访问修饰时默认为default。默认对于同一个包中的其他类相当于公开（public），对于不是同一个包中的其他类相当于私有（private）。受保护（protected）对子类相当于公开，对不是同一包中的没有父子关系的类相当于私有。

 

3.      内部类

内部类（ Inner Class ）就是定义在另一个类里面的类。与之对应，包含内部类的类被称为外部类。

内部类的主要作用如下：

1. 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类

2. 内部类的方法可以直接访问外部类的所有成员，包括私有成员。之所以可以直接访问外部类中的成员，是因为内部类中持有一个外部类的引用，格式：外部类名.this。

3. 外部类要访问内部类中的成员必须要建立内部类的对象。

代码：

public class HelloWorld {

    private int age=10;

    private class Inner { // 内部类Inner，类Inner在类HelloWorld的内部

                   private int age = 20;

                   private void show() {// 内部类的方法

                            System.out.println(age);// 通过System.out.println(HelloWorld.this.age);访问外部类的age

                   }

         }

         public static void main(String[] args) {

                   HelloWorld hello = new HelloWorld();// 创建外部类对象

                   Inner i = hello.new Inner();// 创建内部类对象

                   i.show();//调用内部类对象的方法  但也可以i.age,虽然私有  但是同属一个类中

         }

}

问：内部类有几种呢？

成员内部类

内部类中最常见的就是成员内部类，也称为普通内部类。我们来看如下代码：

 

 

运行结果为：

从上面的代码中我们可以看到，成员内部类的使用方法：

1、 Inner 类定义在 Outer 类的内部，相当于 Outer 类的一个成员变量的位置，Inner 类可以使用任意访问控制符，如 public 、 protected 、 private 等

2、 Inner 类中定义的 test() 方法可以直接访问 Outer 类中的数据，而不受访问控制符的影响，如直接访问 Outer 类中的私有属性a

3、 定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，即：内部类 对象名 = 外部类对象.new 内部类( );

4、 编译上面的程序后，会发现产生了两个 .class 文件

 

其中，第二个是外部类的 .class 文件，第一个是内部类的 .class 文件，即成员内部类的 .class 文件总是这样：外部类名$内部类名.class

另外，友情提示哦：

1、 外部类是不能直接使用内部类的成员和方法，可先创建内部类的对象，然后通过内部类的对象来访问其成员变量和方法。

2、 如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字。如：

 

运行结果：

静态内部类：是 static 修饰的内部类，这种内部类的特点是：

1、 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问 

2、 如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员

3、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();

 

方法内部类：是内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用。由于方法内部类不能在外部类的方法以外的地方使用：

1.不可以被成员修饰符修饰(访问控制符和 static 修饰符)

2.可以直接访问外部类中的成员，因为还持有外部类中的引用。但是不可以访问内部类所在的方法中局部的变量。只能访问被final修饰的局部变量。

 

4.     继承

java只支持单继承，不支持多继承。 但接口之间可以实现多继承(实现)

因为多继承容易带来安全隐患：当多个父类中定义了相同功能，当功能内容不同时，子类对象不确定要运行哪一个。但是java保留了这种机制，并用另一种体现形式来完成表示。多实现。

子类不能继承父类中使用private修饰符修饰的属性和方法

 

二：重写（覆盖）(a.返回值类型  b.方法名 c.参数类型及个数   都要与父类继承方法相同，才叫重写)

子父类中的函数。

当子类出现和父类一模一样的函数时，当子类对象调用该函数，会运行子类函数的内容。如同父类的函数被覆盖一样。

当子类继承父类：沿袭了父类的功能，到子类中，但是子类虽然具备该功能，但是功能的内容却和父类不一致，这时，没有必要定义新功能，而是使用覆盖特殊，保留父类的功能定义，并重写功能内容

重写：

1.子类重写父类方法：必须保证子类重写方法的权限大于等于父类被重写方法的权限(修饰符)，才可以覆盖，否则编译失败。

2.静态只能覆盖静态，不能覆盖非静态。

 

记住大家：

重载：只看同名函数的参数列表。

重写：a.返回值类型  b.方法名 c.参数类型及个数   都要与父类继承方法相同。

 

三：子类中的构造函数

在对子类对象进行初始化时，父类的构造函数也会运行。那是因为子类的构造函数默认第一行有一条隐式的语句super():

super():会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super().

为什么子类一定要访问父类中的构造函数呢？

    因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。所以子类在对象初始化时，要先访问一下父类中的构造函数。如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。

结论：子类的所有的构造函数，默认都会访问父类中空参数的构造函数。因为子类每一个构造函数内的第一行都有一个隐式的super()；当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。

 

四：final

1.可以修饰类、方法、变量、属性。

2.被final修饰的类不可以被继承，被final修饰的方法不可以被重写。

3.被final修饰的变量是一个常量只能赋值一次。

4.final修饰属性，则该类的属性没有默认初始值。赋值方法（选择其中一种）：a.声明时赋值;b.构造方法中赋值;c.构造代码块中赋值。（参考：类成员变量和局部成员变量初始值设置问题）

 

5.   多态

1.多态的体现：

引用多态： 父类的引用可以指向本类的对象

父类的引用指向了自己的子类对象.

方法多态： 创建本类对象时，调用的方法为本类方法.

                    创建子类对象时，调用的方法为子类重写方法或继承方法.(注：不能访问子类特有的方法)

2.多态的前提：必须是类与类之间有关系，要么继承，要么实现(implement)。

3.多态的好处：多态的出现大大的提高程序的扩展性。

4.多态的弊端：不能访问子类特有的方法。

//如果想要调用子类的特有方法时，需要强制将父类的引用转换为子类类型，向下转型。

         子类类名 子类引用 = (子类类名)指向子类对象的父类引用;

         子类引用.子类特有方法();

 /*千万不要出现将父类对象转换成子类类型

*我们能转换的是父类引用指向了自己的子类的对象时，该引用可以被提升(向上类型转换[自动类型转换]是小类型到大类型的转换)也可以强制转换(是大类型到小类型的转换)。多态自始至终都是子类对象在做着变化。*/

instanceof运算符：返回boolean类型的数据

1：判断其左边对象是否为其右边类的实例.

2：可以用来判断继承中的子类的实例是否为父类的实现.

3：用在对象的强制转换。

4：用在多态中，判断左边父类引用变量指向的对象是否是右边类的实例.

 

二：在多态中成员函数的特点

例如：Fu f=new Zi();

在编译时期：参阅引用型变量所属的类中是否有调用的方法，如果有，编译通过，如果没有编译失败。

在运行时期：参阅对象所属的类中是否有调用的方法。

简单来说：成员函数在多态调用时，编译看左边，运行看右边。

 

在多态中，成员变量的特点：

无论编译和运行，都参考左边（引用型变量所属的类）。(也就是说变量之间不存在重写)

 

在多态中，静态成员函数的特点：

无论编译和运行，都参考左边

 

三：抽象方法

当多个类中出现相同功能，但是功能主体不同。这时可以进行向上抽取。这时，只抽取功能的定义，而不抽取功能主体

在某些情况下，某个父类只知道子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法。

 

抽象类的特点:

1.抽象方法一定在抽象类中。(有抽象方法一定是抽象类，但抽象类中不一定有抽象方法)

2.抽象方法和抽象类都必须被abstract关键字修饰。

3.抽象类不可以用new创建对象。因为调用抽象方法没有意义。

4.抽象类中的抽象方法要被调用，必须有由子类重写所有的抽象后，建立子类对象调用。如果子类只重写了部分抽象方法，那么子类还是一个抽象类。

5.抽象类中的变量默认是friendly型，其值可以在子类中重新定义，也可以重新赋值。(抽象类可以有成员变量，但不能用abstract修饰)

 

四：接口

初期理解，可以认为是一个特殊的抽象类，当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。

class用于定义类

interface用于定义接口。

 

接口的定义，格式特点：记住：接口中的成员都是public

1.接口中常见定义：常量，抽象方法。

2.接口中的成员都有固定修饰符。

接口中定义的变量默认是：public static final  即使定义时不添加，系统也会自动添加上去

接口中的方法默认是：public abstract  即使定义时不添加，系统也会自动添加上去

接口：是不可以创建对象的，因为有抽象方法，需要被子类实现，子类对接口的抽象方法全都重写后，才可以实例化，否则子类是一个抽象类。

 

接口的基本语法：接口之间可以实现多继承

 [修饰符] interface 接口名 [extends 父接口1，父接口2...]{ }

1、接口是一种规范。接口里全是public static final属性，或者abstract方法

2、接口就是用来被继承、被实现的，所以不能用private和protected修饰

3、实现接口使用implements 如：

  [修饰符] class 类名 extends 父类 implements 接口1，接口2...{ }

如果要继承父类，继承父类必须在实现接口之前.

4、接口还经常与匿名内部类配合使用

5、一个类可以实现一个或多个接口，而java中一个类只能继承一个父类。

 

抽象类与接口的区别（前四点很重要）：

1. 抽象类可以提供普通成员方法，而接口中只能存在public abstract 方法（公共抽象方法）；
2. 抽象类中的成员变量可以被不同的修饰符来修饰，而接口中的成员变量只能被public static final修饰；
3. 抽象类可以有静态代码块和静态方法，而接口中不能含有静态代码块以及静态方法；
4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口；
5. 接口与其成员方法不需要添加abstract，系统默认自动添加，而抽象类与其抽象方法需要abstract修饰；
6. 抽象类是对象的抽象，然而接口是一种行为规范。