Java详解包、访问权限修饰符、封装、继承、多态、方法的重写、抽象类、接口、final关键词

目录

1.包

2.访问权限修饰符

3.封装

4.继承

5.方法重写

6.抽象类

7.多态

8.final关键字

9.接口

---

1.包

        包的概念：用来管理类，用于为类当做命名空间（地址）

        1.包：（全类名=包名+类的简称）

        import用来导入其他包中的类，同包中使用不需要导入。

        在java中java.lang包中的不需要导入，可以直接使用。

        2.包的作用：

        1）避免类重名。

        2）按照不同功能管理类 公共的功能，数据库交互的功能，与前端交互的功能。

        3）控制访问权限。

        3.包的命名规范：

        在包名中，可以使用点（.）号来区分包的级别；

        包名一般情况下是小写 。

        第一级 指该项目的类型，如com,org,gov等

        第二级 指项目所开发或者运行的公司名称，如：oracle,sun,huawei 等

        第三级 指项目的名称，如：bcms,oa,erp,cms等

        第四级 指项目模块的名称，如：bean,action,exception等

2.访问权限修饰符

        1.访问权限修饰符

        1）public ：公共权限 修饰类、属性、方法。可以被任意类访问。

        2）protected：受保护的权限 修饰属性、方法。

        可以被同包类访问，如果不是同包类，必须是该类的子类才可以访问。

        3）default：同包权限 修饰类、属性、方法。只能被同包的类访问。

        4）private：私有权限 修饰属性、方法。 只能在本类中访问。

        这四种访问权限修饰符也都可以修饰内部类。

3.封装

        1.封装广义：多次验证账号密码是否正确，抽取一个check().封装(包装)。

        2.面向对象语言三大特征：封装、继承、多态。

        面向对象语言中的封装是对类中的信息进行隐藏（访问权限），不让外部知道类中有哪些信息（成员变量、方法）。

1.面向对象特征——封装：将类中的某些信息隐藏起来。

        设计模式：前任总结出的解决某类问题的最有方案（模板）。

        单例模式：需要某个类在整个应用程序中，只能创建一个对象。

        //属性私有化 是封装的一种体现，提供外界能够访问到的方法

        //构造方法私有化

public class Demo {
    private String name;//将成员变量私有化 提供公开的方法进行修改和调用
    private int age;
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
}

4.继承

1.子类继承父类 使用父类中已经实现好多功能，而且子类还可以扩展自己的功能。

（面向对象设计宗旨：代码复用性高，扩展性强。）

2.什么情况下用继承：满足 什么是什关系。具体语法：使用extends关键字。

例如：根据Animal派生出一个狗类

           子类就会拥有父类中非私有的属性和行为，默认的

           子类也可以扩展自己的特有属性和行为

3.java中一个类只能直接继承一个父类，不允许多继承，但是支持多级继承传递。

4.当一个类没有显示的继承其他类时，那么默认继承是Object(Object是java中所有类的父类/基类)。

5.子类的构造方法在被调用时，必须在构造方法的第一行调用父类任意的构造方法，使用super.

   //super(); 系统默认在第一行调用父类无参构造。

6.如果没有显示的调用父类的构造方法，那么系统默认在构造方法的第一行调用父类无参构造。

7.因为创建子类对象后，子类对象可以访问父类的信息，所以在初始化子类之前，必须先初始化父类。

public abstract class Animal {

    private String name;
    private int age;

    public abstract void eat();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

}

public class Dog extends Animal {

    @Override
    public void eat() {
        System.out.println("狗吃饭");
    }
}
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();
    }
}

5.方法重写

当父类的方法实现不能满足子类需求时,可以对方法进行重写。

        • 方法名相同、参数列表相同；

        • 返回值类型相同；

        • 访问权限不能小于父类权限;

注意：构造方法,静态方法不能重写,成员变量不存在重写。

6.抽象类

        1.抽象类：如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

        2.抽象类除了不能实例化对象之外，类的其他功能依然存在，成员变量、成员方法、构造方法。

        3.用abstract修饰的类就是抽象类。如果某个类中包含有抽象方法，那么该类就必须定义成抽象类。

        若父类为抽象类，则子类必须为抽象类或者将父类中的抽象方法重写。

        具体语法：

        [访问权限] abstract class 类名 {
        成员列表

        }

特点：

        抽象类不能被实例化，但可以有构造方法，因为抽象类中含有无具体实现方法，所有不能用抽象类创建对象。

        抽象类只能作基类，表示的是一种继承关系。继承抽象类必须实现其中的所有抽象方法，而已实现方法的参数、返回值要和抽象类中的方法以一种。否则，该类也必须声明为抽象类。

案例如下：

public abstract class Animal {

    private String name;
    private int age;

    public abstract void eat();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }


}

        抽象类，抽象方法，在软件开发过程中都是设计层面的概念。也就是说，设计人员会设计出抽象类，抽象方法，程序员都是来继承这些抽象类并覆盖抽象方法，实现具体功能。

7.多态

        概念：同一种事物，在不同时刻不同的状态。

        多态存在的三个必要条件

        1.首先要有继承（包括接口的实现）（前提条件）

        2.要有重写（前提条件）

        3.父类引用指向子类对象

当编译期类型是父类，运行期类型是子类时，被称为父类引用指向子类对象

public abstract class Animal {

    private String name;
    private int age;

}
public class Dog extends Animal {

}
public class Test {
    public static void main(String[] args) {
        Animal dog = new Dog();
    }
}

多态环境下对成员方法的调用

简单说：编译看左边，运行看右边

public abstract class Animal {

    private String name;
    private int age;

    public abstract void eat();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

}
public class Dog extends Animal {

    public void eat() {
        System.out.println("狗吃饭");
    }
}
public class Test {
    public static void main(String[] args) {
        Animal dog = new Dog();
        dog.eat();
    }
}

多态环境下对静态成员方法的调用        简单来说：编译和运行都看左边

class Animal{
    static void show(){
    System.out.println("Animal");
    }
}
class Cat extends Animal{
    static void show(){
    System.out.println("Cat");
    }
}
public static void main(String[] args){
    Animal a = new Cat();
    a.show();//调用的时动物类中的静态成员方法  
}

多态环境下对成员变量的调用 简单说：编译和运行都看等号左边

注意：变量不存在被子类覆写这一说法，只有方法存在覆写。

class Animal{
    int num = 3;
}
class Cat extends Animal{
    int num = 4;
}
public static void main(String[] args){
    Animal x= new Cat();
    x.num; //调用的是动物类的成员变量
}

方法参数具有多态性        方法参数多态性的好处：提高代码的扩展

class Animal{
    void eat(){}
}
class Cat extends Animal{
    void eat(){}
}
class Dog extends Animal{
    void eat(){}
}
//方法的形式参数类型是父类类型，而传递的时间参数可以是任意子类的对象
method(Animal animal){
    aniaml.eat();
}

向上转型 向上        转型的作用是：提高程序的扩展性

class Animal{
    void eat(){}
}
class Cat extends Animal{
    void look(){
     System.out.println("看家");
    }
}
Animal a = new Cat();
a.eat(); //只能使用父类的方法
a.look(); //报错不能使用子类中方法

向下转型        作用：为了使用子类中的特有方法。

class Animal{
    void eat(){}
}
class Cat extends Animal{
    void look(){
    System.out.println("看门");
    }
}

Animal x = new Cat();
Cat m = (Cat) x;    //    向下转型
m.eat();
m.look(); //子父类中的方法都可以使用

8.final关键字

final用于声明属性，方法和类

        属性：定义就必须直接赋值或者在构造方法中进行赋值，并且后期都不能修改

        方法：子类里不可以重写

        类：不能被定义为抽象类或者接口，不可被继承。

/*final属性赋值
    1.在声明的同时赋值，往往与static一起使用
    2.声明时不赋值，必须在构造方法中逐一赋值
    3.总的原则：保证创建每一个对象的时候，final属性的值时确定的。
*/
private in index;
private final int level; 
private static final double PI = 3.14;
public Test(){
    level =0 ;
}
public Test(int index){
    this.index = index;
    leve = 1
}

对参数做final修饰。

        在方法参数前面假final关键词，为了防止数据在方法体中被修改。

9.接口

       可以使用Java接口来实现

面向接口编程

        程序设计时：1.关系实现类有何能力，而不关心实现细节。

                              2.面向接口的约定而不考虑接口的具体实现

        从本质讲，接口时一种特殊的抽象类，这种抽象类中包含抽象方法。

认识接口

public interface MyInterface{
    int num = 10;    //所有属性默认为：public static final
    public void foo();    //抽象方法时：public abstract
    public static oid test(){    //jdk8之后添加静态方法接口可以直接调用
        }
    public default void test1(){ //jdk8之后添加默认方法，通过子类调用
    }
}

 接口的定义和使用

       接口的定义：使用interface 关键词用来声明一个接口。 

        接口可以继承其他接口 

        [访问修饰符 ] interface 接口名称 [extends 其他的接口名 1,…. 其他的接口名 n]

        {

                // 声明常量 抽象方法 静态方法 默认方法

         }

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

        可以同时实现多个接口

        [访问修饰符 ] class 类名 implements 接口名 1 ，接口名 2……{ }

        结合继承：

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

接口的特性

        接口时隐式抽象的，当声明一个接口的时候，不必使用abstract关键词

        接口中方法可以时抽象的，静态的，默认的

        接口中声明的属性默认为 public static final的

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

        接口不能实例化对象

        与继承关系相似，接口与实现类之间存在多态性

        一个接口能继承其他多个接口

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