Java 类001-访问修饰符命名规范

Posted 2023-03-17

【Java 类】001-访问修饰符、命名规范

文章目录

• ​​【Java 类】001-访问修饰符、命名规范​​
• ​​一、访问修饰符概述​​

• ​​1、是什么​​
• ​​2、作用​​

• ​​作用​​
• ​​问题​​

• ​​3、访问修饰符有哪些​​
• ​​4、作用对象​​

• ​​二、访问修饰符使用演示​​

• ​​1、类访问修饰符演示​​

• ​​第一步：创建 `Dog` 类：public​​
• ​​第二步：同包下创建 `Cat` 类：default​​
• ​​第三步：在 `domain` 包下创建 `Pig` 类：default​​
• ​​第四步：创建 `Main` 类​​
• ​​第五步：查看提示 `Pig` 类无法访问​​

• ​​2、方法访问修饰符访问​​

• ​​第一步：创建 `Dog` 类​​
• ​​第二步：在同包下创建 `Main` 类​​
• ​​第三步：在不同包下创建 `Main` 方法​​
• ​​第四步：在不同包下创建 `DogSon` 类​​
• ​​第五步：演示 `private` 方法本类可访问​​

• ​​3、属性访问修饰符演示​​

• ​​第一步：创建 `Dog` 类​​
• ​​第二步：在同包下创建 `Main` 类​​
• ​​第三步：在不同包下创建 `Main` 类​​
• ​​第四步：在不同包下创建 `DogSon` 类​​
• ​​第五步：演示 `private` 属性本类而可访问​​
• ​​扩展：Java 中为什么子类的 `main` 方法中通过父类对象的实例访问 `protected` 方法报错？​​
• ​​扩展：Java 中为何同类下的 `main` 方法可以直接通过当前类对象访问 `private` 属性？​​

• ​​三、包命名规范​​
• ​​四、类命名规范​​
• ​​五、变量命名规范​​
• ​​六、常量命名规范​​
• ​​七、方法命名规范​​
• ​​八、泛型命名规范​​

一、访问修饰符概述

1、是什么

Java访问修饰符是一种关键字，用来控制类、方法和变量的访问权限。

2、作用

作用

1. 封装性：访问修饰符可以用来限制其他类对于某个类、方法或变量的访问，从而保护类的数据安全性，实现类的封装。

Java 面向对象的封装性就依赖访问修饰符来实现！

1. 可读性：访问修饰符可以用来表明类、方法或变量的访问范围，使代码更易于理解和维护。

我对这种可读性的理解是对于访问范围进行了直接标明！

1. 重用性：访问修饰符可以用来控制子类对于父类中属性和方法的访问，从而实现代码的重用。

我觉得更多的，访问修饰符对这方面提供了灵活的控制！我觉得子类继承父类最大的目的就是为了代码复用，访问修饰符提供了灵活的控制！

1. 可维护性：访问修饰符可以用来限制对于某个类、方法或变量的访问，从而使得修改代码更加容易，不会影响其他部分的代码。

访问修饰符限制了可访问范围，代码修改带来的影响也是在一定范围内的！

1. **安全性：**访问修饰符可以用来限制对于某个类、方法或变量的访问，从而提高程序的安全性，防止恶意操作或者不合理的访问。

限制的大多数目的就是为了安全！凡是容易造成安全问题的行为都应该得到限制！目标 => 策略 => 规则（限制）！

总之，Java访问修饰符可以用来控制程序中各个部分的访问范围，从而实现类的封装，增强程序的可读性、重用性、可维护性和安全性。

问题

访问修饰符并不是只有优点，也会带来一些问题！如带来了程序设计的复杂性，垂直和水平方向的访问限制设置提高了对软件开发人员的要求，如果访问修饰符使用不当，会导致代码的可读性大大降低，提高了系统的复杂性！访问修饰符设置得当的时候，往往带来很多好处，但如果设置不当便适得其反！

3、访问修饰符有哪些

Java中有四种访问修饰符，它们分别是：

1. public（公共的）：被声明为 ​​public​​ 的类、方法和变量可以被任何其他类访问。
2. protected（受保护的）：被声明为 ​​protected​​ 的方法和变量只能被同一包内的其他类访问，或者是其他包中的子类访问。
3. default（默认的）：如果没有指定任何访问修饰符，则默认为 ​​default​​ ，被声明为default的方法和变量只能被同一包内的其他类访问。
4. private（私有的）：被声明为 ​​private​​ 的方法和变量只能被同一类内部的其他方法访问，不能被其他类访问。

4、作用对象

Java访问修饰符可以用于以下三个对象：

1. 类：Java 中的类可以使用 ​​public​​​ 和 ​​默认​​​ 的访问修饰符。如果使用 ​​public​​ 访问修饰符，这个类将被其他任何类所访问。如果使用 ​​默认​​ 的访问修饰符，则只能在同一包内的其他类中访问这个类。
2. 方法：Java 中的方法可以使用 ​​public​​​、​​protected​​​、​​private​​​和 ​​默认​​​ 的访问修饰符。如果使用 ​​public​​ 访问修饰符，这个方法将被其他任何类所访问。如果使用 ​​protected​​ 访问修饰符，这个方法将被同一包中的其他类和其他包中的子类所访问。如果使用 ​​private​​ 访问修饰符，这个方法只能在同一类中访问。如果使用 ​​默认​​ 的访问修饰符，则只能在同一包中的其他类中访问这个方法。
3. 变量：Java 中的变量可以使用 ​​public​​​、​​protected​​​、​​private​​​和 ​​默认​​​ 的访问修饰符。如果使用 ​​public​​ 访问修饰符，这个变量将被其他任何类所访问。如果使用 ​​protected​​ 访问修饰符，这个变量将被同一包中的其他类和其他包中的子类所访问。如果使用 ​​private​​ 访问修饰符，这个变量只能在同一类中访问。如果使用 ​​默认​​ 的访问修饰符，则只能在同一包中的其他类中访问这个变量。

在实际开发中，访问修饰符的选择应该根据具体的需求和业务逻辑，合理地使用访问修饰符，避免过度使用访问修饰符，降低代码的可读性和灵活性。同时，需要保持代码的简洁和清晰，避免过度的复杂性和实现细节的暴露。

二、访问修饰符使用演示

1、类访问修饰符演示

第一步：创建 Dog 类：public

package main;

/**
 * @author zibo
 * @date 2023/3/5 12:05
 * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
 */
public class Dog 

第二步：同包下创建 Cat 类：default

package main;

/**
 * @author zibo
 * @date 2023/3/5 12:07
 * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
 */
class Cat 

第三步：在 domain 包下创建 Pig 类：default

package domain;

/**
 * @author zibo
 * @date 2023/3/5 12:11
 * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
 */
class Pig 

第四步：创建 Main 类

package main;

import domain.Pig;

/**
 * @author zibo
 * @date 2023/3/5 12:06
 * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
 */
public class Main 
    public static void main(String[] args) 
        // public 修饰的类，可以在任何地方被访问
        Dog dog = new Dog();
        // default 修饰的类，只能在同一个包中被访问
        Cat cat = new Cat();
        // default 修饰的类，只能在同一个包中被访问
        new Pig();
    

第五步：查看提示 Pig 类无法访问

2、方法访问修饰符访问

第一步：创建 Dog 类

package main;

/**
 * @author zibo
 * @date 2023/3/5 12:16
 * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
 */
public class Dog 

    /**
     * public 方法：可以被任何类访问
     */
    public void publicMethod() 
        System.out.println("publicMethod");
    

    /**
     * protected 方法：可以被同一个包下的类访问，也可以被不同包下的子类访问
     */
    protected void protectedMethod() 
        System.out.println("protectedMethod");
    

    /**
     * default 方法：可以被同一个包下的类访问
     */
    void defaultMethod() 
        System.out.println("defaultMethod");
    

    /**
     * private 方法：只能被本类访问
     */
    private void privateMethod() 
        System.out.println("privateMethod");
    

第二步：在同包下创建 Main 类

package main;

/**
 * @author zibo
 * @date 2023/3/5 12:06
 * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
 */
public class Main 
    public static void main(String[] args) 
        Dog dog = new Dog();
        dog.publicMethod();
        dog.protectedMethod();
        dog.defaultMethod();
        dog.privateMethod(); // 私有方法报错
    

私有方法报错

第三步：在不同包下创建 Main 方法

package test;

import main.Dog;

/**
 * @author zibo
 * @date 2023/3/5 12:18
 * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
 */
public class Main 

    public static void main(String[] args) 
        Dog dog = new Dog();
        dog.publicMethod();
        dog.protectedMethod(); // 不同包下的非子类访问报错
        dog.defaultMethod(); // 不同包下的类访问报错
        dog.privateMethod(); // 私有方法报错
    

错误提示

第四步：在不同包下创建 DogSon 类

package test;

import main.Dog;

/**
 * @author zibo
 * @date 2023/3/5 12:22
 * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
 */
public class DogSon extends Dog 

    /**
     * 子类访问父类的 public 方法
     */
    public void testPublicMethod() 
        publicMethod();
    

    /**
     * 子类可以访问父类的 protected 方法
     */
    public void testProtectedMethod() 
        protectedMethod();
    
    
    /**
     * 子类不能访问父类的 default 方法
     */
    public void testDefaultMethod() 
        defaultMethod(); // 报错
    
    
    /**
     * 子类不能访问父类的 private 方法
     */
    public void testPrivateMethod() 
        privateMethod(); // 报错
    

错误提示

第五步：演示 private 方法本类可访问

package main;

/**
 * @author zibo
 * @date 2023/3/5 12:30
 * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
 */
public class Dog 

    /**
     * private 方法：只能被本类访问
     */
    private void privateMethod() 
        System.out.println("privateMethod");
    

    public static void main(String[] args) 
        Dog dog = new Dog();
        dog.privateMethod();
    

3、属性访问修饰符演示

第一步：创建 Dog 类

package main;

/**
 * @author zibo
 * @date 2023/3/5 12:31
 * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
 */
public class Dog 

    /**
     * public 变量：可以被任何类访问
     */
    public String publicVariable = "publicVariable";

    /**
     * protected 变量：可以被同一个包下的类访问，也可以被不同包下的子类访问
     */
    protected String protectedVariable = "protectedVariable";

    /**
     * default 变量：可以被同一个包下的类访问
     */
    String defaultVariable = "defaultVariable";

    /**
     * private 变量：只能被本类访问
     */
    private String privateVariable = "privateVariable";

第二步：在同包下创建 Main 类

package main;

/**
 * @author zibo
 * @date 2023/3/5 12:35
 * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
 */
public class Main 
    public static void main(String[] args) 
        Dog dog = new Dog();
        System.out.println(dog.publicVariable);
        System.out.println(dog.protectedVariable);
        System.out.println(dog.defaultVariable);
        System.out.println(dog.privateVariable); // 报错
    

错误提示

第三步：在不同包下创建 Main 类

package test;

import main.Dog;

/**
 * @author zibo
 * @date 2023/3/5 12:18
 * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
 */
public class Main 

    public static void main(String[] args) 
        Dog dog = new Dog();
        System.out.println(dog.publicVariable);
        System.out.println(dog.protectedVariable); // 报错
        System.out.println(dog.defaultVariable); // 报错
        System.out.println(dog.privateVariable); // 报错
    

错误提示

第四步：在不同包下创建 DogSon 类

package test;

import main.Dog;

/**
 * @author zibo
 * @date 2023/3/5 12:22
 * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
 */
public class DogSon extends Dog 

    /**
     * 子类访问父类的 public 属性
     */
    public void testPublicProperty() 
        System.out.println(publicVariable);
    

    /**
     * 子类可以访问父类的 protected 属性
     */
    public void testProtectedProperty() 
        System.out.println(protectedVariable);
    

    /**
     * 子类访问父类的 default 属性
     */
    public void testDefaultProperty() 
        System.out.println(defaultVariable); // 报错
    

    /**
     * 子类不能访问父类的 private 属性
     */
    public void testPrivateProperty() 
        System.out.println(privateVariable); // 报错
    

    public void myPrint(String[] args) 
        System.out.println(protectedVariable); // 这种可以！
        Dog dog = new Dog();
        System.out.println(dog.publicVariable);
        System.out.println(dog.protectedVariable); // 报错：注意这种方式是不行的
        System.out.println(dog.defaultVariable); // 报错
        System.out.println(dog.privateVariable); // 报错
    

第五步：演示 private 属性本类而可访问

package main;

/**
 * @author zibo
 * @date 2023/3/5 13:07
 * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
 */
public class Dog 

    /**
     * private 变量：只能被本类访问
     */
    private String privateVariable = "privateVariable";

    public static void main(String[] args) 
        Dog dog = new Dog();
        System.out.println(dog.privateVariable); // 这里可以访问，和 protected 在非同包子类不同
    

扩展：Java 中为什么子类的 main 方法中通过父类对象的实例访问 protected 方法报错？

在 Java 中，​​protected​​ 修饰符用于限制只有同包下其他类和其子类可以访问该成员变量或方法。因此，如果你在子类的 ​​main​​ 方法中通过父类对象的实例访问 ​​protected​​ 方法，会出现编译错误。这是因为子类虽然继承了父类的 protected 方法，但是并不能通过父类对象的实例来直接访问该方法。

要访问父类的 ​​protected​​ 方法，可以在子类中创建一个方法来调用该方法。例如，可以在子类中创建一个公共方法，该方法通过 ​​super​​​ 关键字调用父类的 ​​protected​​​ 方法，然后从 ​​main​​ 方法中调用该公共方法。以下是示例代码：

public class Parent 
    protected void myMethod() 
        System.out.println("This is a protected method");
    


public class Child extends Parent 
    public void callProtectedMethod() 
        super.myMethod();
    

    public static void main(String[] args) 
        Child child = new Child();
        child.callProtectedMethod();
    

在上面的示例中，​​Child​​​ 类继承了 ​​Parent​​​ 类的 ​​protected​​​ 方法 ​​myMethod()​​​，并创建了一个公共方法 ​​callProtectedMethod()​​​，该方法通过super关键字调用了父类的 ​​myMethod()​​​ 方法。然后在 ​​main​​​ 方法中，创建 ​​Child​​​ 类的对象 ​​child​​​，并通过调用 ​​callProtectedMethod()​​​ 方法来访问父类的 ​​protected​​ 方法。

扩展：Java 中为何同类下的 main 方法可以直接通过当前类对象访问 private 属性？

这是因为 Java 中的访问控制是基于类而不是基于对象的。私有属性被声明为 ​​private​​​ 后，只有该类的其他方法可以访问它，而其他类的对象无法直接访问该属性。但是，由于 ​​main​​ 方法和其他方法都属于同一个类，因此它们都可以直接访问该类的私有属性。

package main;

/**
 * @author zibo
 * @date 2023/3/5 13:22
 * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
 */
public class Dog 
    
    private static String privateStaticVariable = "privateStaticVariable";
    private String privateVariable = "privateVariable";
    public String publicVariable = "publicVariable";

    /**
     * 普通方法访问 private 变量
     */
    public void myPrint() 
        System.out.println(privateStaticVariable);
        System.out.println(privateVariable);
        System.out.println(publicVariable);
        System.out.println(new Dog().privateVariable);
    

    /**
     * 静态方法访问 private 变量
     */
    public static void myStaticPrint() 
        System.out.println(privateStaticVariable);
        System.out.println(privateVariable); // 报错，静态方法不能访问非静态变量
        System.out.println(publicVariable); // 报错，静态方法不能访问非静态变量
        // 私有方法，只能在本类中访问，静态方法中不能访问非静态变量
        // 所以不能访问，但是可以通过对象访问，另外静态方法是可以直接访问本类的静态属性的
        System.out.println(new Dog().privateVariable); // 正常，私有普通属性是属于对象的，所以可通过对象访问
        System.out.println(new Dog().publicVariable); // 正常，私有普通属性是属于对象的，所以可通过对象访问
    

三、包命名规范

1. 包名应该全部小写。
2. 包名应该基于逆域名命名，例如，一个公司的域名为 ​​example.com​​​，则该公司编写的 Java 代码的根包名应该是 ​​com.example​​。
3. 包名应该简短而有意义，能够反映出包中包含的类的功能。
4. 如果一个包名由多个单词组成，单词之间都应该都点 ​​.​​​ 隔开，例如：​​com.example.myapp​​。
5. 不要在包名中使用下划线或其他特殊字符，因为这可能会导致一些问题。

四、类命名规范

1. 类名应该以大写字母开头，采用驼峰式命名规则，例如：​​MyClass​​​，而不是​​myClass​​​ 或 ​​MYCLASS​​。
2. 类名应该是名词，而不是动词。
3. 类名应该简明扼要地描述类的职责和功能，同时尽量避免使用缩写。
4. 如果一个类名由多个单词组成，每个单词的首字母都应该大写，例如：​​MyFirstClass​​。
5. 接口名也应该采用相同的规范，以便于与类名进行区分，例如：​​MyInterface​​。
6. 抽象类的命名应该以 ​​Abstract​​​ 开头，例如：​​AbstractClass​​。
7. 子类：如果一个类是某个类的子类，应该在父类名后面加上一个单词来描述它的特定功能，例如：​​MySubClass​​。
8. 接口实现类：应该在类名后面加上 ​​Impl​​​，例如：​​MyClassImpl​​。
9. 异常类：为了和普通类做出区别，一般以 “​​Exceptiont​​” 作为后缀。
10. 测试类：为了和普通类做出区别，一般以“​​Test​​”作为后缀。
11. 枚举类：为了和普通类做出区别，一般以“​​Enum​​”作为后缀，枚举类中的值遵循常量的命名规范。

五、变量命名规范

1. 通常是见名知意的名词。
2. 首字母小写。
3. 多个单词时，采用驼峰命名法。
4. 不建议使用中文缩写来命名。
5. 不建议使用下划线作为连接。

六、常量命名规范

1. 通常是见名知意的名词。
2. 全部大写字母。
3. 多个单词之间使用“​​_​​”进行分隔。
4. 不建议使用中文缩写来命名。

七、方法命名规范

1. 通常是见名知意的名词。
2. 首字母小写。
3. 多个单词时，采用驼峰命名法。
4. 不建议使用中文缩写来命名。
5. 不建议使用下划线作为连接。
6. 有返回值的方法一般加“​​get​​”前缀。
7. 设置的方法一般加对应的动词作为前缀（如：​​set​​、​​insert​​、​​update​​、​​delete​​）。
8. 查询的方法一般加“​​select​​”或“​​find​​”或“​​query​​”作为前缀。
9. 带有条件的方法一般在命名中使用“​​by​​”或“​​with​​”等字符。
10. 判断的方法一般以“​​is​​”作为前缀。
11. 测试方法一般以“​​test​​”作为前缀。

八、泛型命名规范

1. E 表示 Element，通常用在集合中。
2. T 表示 Type（类型），通常指类。
3. K 表示 Key（键），通常用于 Map 中。
4. V 表示 Value（值），通常用于 Map 中，与 K 成对出现。
5. N 表示 Number，通常表示数值类型。
6. ? 表示不确定的 Java 类型。
7. X 表示异常。
8. U,S 表示任意类型。

java：包继承，访问修饰符

包

包(package) 用于管理程序中的类，主要用于解决类的同名问题。包可以看出目录。

 

包的作用

[1] 防止命名冲突。

[2] 允许类组成一个单元(模块),便于管理和维护

[3] 更好的保护类、属性和方法 

包命名规范

包命名原则:始终保持类的全路径唯一。

 

规范：

[1]包名由小写字母组成，不能以圆点开头或结尾。圆的有特殊意义——包分隔符

 

[2]包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名。如：域名javagroup.net

package net.javagroup.xx

[3]包名后续部分依不同机构内部的规范不同而不同

package net.javagroup.project1.projectname.xx

 在控台如何编译包：javac   -d   ./(当前文件夹)  ./Tset01.java      (javac -d  编译目的地   源文件)没个都有空格

编译完成后，Test01的全路径是cn.huang001.Test01   

注意：编译时还没有包出来，不能用源文件的全路径形式

 

 

 

1.1 jvm提供的包

包名	描述
java.lang/语言包	系统默认导入，String类保存在这个包中，所以我们在使用String时不需要导包
java.util	工具包，一些常用的类库，Scanner,Date,Arrays
java.io	输入输出处理，文件的读写等
java.net	网络编程
java.math	数学计算.Math.random
java.awt(C)	这个包中的类用于构建和管理应用程序的图形用户界面

 

为什么要使用继承？

为了提取两个类中公共的代码，可以使用继承抽取重复性的代码到一个公共类中，这个公共的类称为父类(super class)。继承于父类的类称为子类(sub class).

 

java继承的特性

[1] 单根性。在java中，一个类只能有一个直接父类。

[2] 传递性。C继承于B，B继承于A，C具有A的特性和行为。

 

 

类B继承于类A，使用关键字extends，B拥有了A中非私有的属性和方法。

 

变量隐藏(C)

 

当子类定义了一个和父类同名的属性时，在子类中优先访问子类的属性，如果要访问父类属性一定要加super。

//如果引入两个相同名字的类时，其中一个可以用import，另一个如下

//其中一个在创建对象时写全路径  

//java.util.Date date1 = new java.util.Date()

//用于定义包的位置 package 包名.包名
package cn.car;
//必须写到源代码的第一句
import cn.car.*;   //导入cn.car下的所有类
//import 用于导包，告诉类需要的其他类在什么位置！
//（在同一包不需要导入）
public class Test01{
    public static void main(String[] args){
        Carriage ca=new Carriage("","汽车","武大郎");
        ca.carriage();
        Taxi caa=new Taxi("","京B123","景顺出租车公司");
        caa.taxi();
        
    }
}

//java继承父类（公共类）是多个类的共有的属性和方法
//单根性。在java中，一个类只能有一个直接父类。
//传递性。C继承于B，B继承于A，C具有A的特性和行为。


//父类
package cn.car;

public class Car{
   private String motorcyle;
  private String number;
  
  public void setMotorcyle(String motorcyle){
      this.motorcyle=motorcyle;
  }
  public String getMotorycle(){
      return this.motorcyle;
  }
   public void setNumber(String number){
       this.number=number;
   } 
   public String getNumber(){
       return this.number;
   }
  public  Car(){
      
  }
  public Car(String motorcyle,String number){
      this.setMotorcyle(motorcyle);
      this.setNumber(number);
  }
}

//java继承子类
//类B继承于类A，使用关键字extends，B拥有了A中非私有的属性和方法。
//导入cn.car下的Carriage类
//先导入父类在继承父类（同一包不需要导入）
//子类不能继承private成员，不能继承构造方法，父类子类不在同包不能使用默认访问

//子类
package cn.car;
import cn.car.Car;
public class Carriage extends Car{
private String name;
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}



public Carriage(){//无参构造

}//有参构造
public Carriage(String motorcyle,String number,String name){
super(motorcyle,number);
this.setName(name);
}
public void carriage(){
System.out.println("我是"+this.name+"，我的"+super.getNumber()+"我做主");
System.out.println("目的地到了，我们去玩吧");
}
}

 

//java继承子类
//类B继承于类A，使用关键字extends，B拥有了A中非私有的属性和方法。
package cn.car;
import cn.car.Car;
public class Taxi extends Car{
private String company;

public void setCompany(String company){
    this.company=company;
}
public String getCompany(){
    return this.company;
}

public Taxi(){
    
}
public Taxi(String motorcyle,String number,String company){
    //super关键字表示父类对象，只是一个关键字，里面没有引用
    //super调用父类构造方法时，必须写到构造方法有效代码第一句
    super(motorcyle,number);
    //super可以访问父类的非私有属性。私有的属性不能用super访问。
    this.setCompany(company);
}    public void taxi(){
    System.out.println("乘客您好");//// 当需要访问父类的属性时，优先使用super
    System.out.println("我是"+company+"的，我的车牌是"+super.getNumber()+"，您要去哪里？");
    System.out.println("目的地已经到了，请您付费下车，欢迎再次乘坐");
}//super.父类方法名();  可以把父类的方法继承过来

}/*如果要访问父类属性，通过super；如果要访问子类属性，通过this.

当子类定义了一个和父类同名的属性时，
在子类中优先访问子类的属性，如果要访问父类属性一定要加super。*/

 

 

 

静态导入

如果一个类中定义的属性和方法都是静态时，可以考虑使用静态导入。jdk1.5+ 出现。

如果子类 父类 全是静态变量或方法 就可以静态导入，静态导入后可以直接提取类中的变量和方法

import static cn.sxt01.Calc.*;

 

1.1 访问修饰符

java中存在4类访问修饰符，分别是private、默认、protected、public。

 

修饰符	本类✘	同包子类	同包其他类	不同包子类	不同包其他类
private	✔	✘	✘	✘	✘
默认	✔	✔	✔	✘	✘
protected	✔	✔	✔	✔	✘
public	✔	✔	✔	✔	✔

 

private:私有的,只能在本类可以访问。

friendly:默认的,同包可访问，也称包访问权限。

protected:受保护的, ①子类可访问 ②同包可访问 

public:公共的,都可以访问

 

 

 继承关系的初始化顺序

继承关系内存图