package,继承,访问修饰符

1.package

包(package),用于管理程序中的类,可用于处理类的同名问题。

1.1定义package的方法

package 包名;

package用于定义包,必须写在源文件有效代码的第一句。

1.2编译带有包的源文件

在控制台编译有包的源文件,javac -d 目的位置 源文件位置。如下

1.3.import导包

同一包中的其他类可以直接使用。

如果要使用不在同一个包中的类,需要用import导入。

import java.util.Scanner;//导入java.util下的Scanner类

1.3.1如果要使用到不同包中,但是名字相同的类要如何处理呢?以导入java.util.Date;和java.sql.Date;为例。

1 java.util.*;  //导入java.util下所有的类
2
3 java.sql.Date;//导入java.sql下的Date类

1.3.2静态导入

静态导入,在jdk1.5后开出现的。当类中的属性和方法都是静态的时候可以使用。如下

1 package cn.qd01;
2 public class Calc{
3     public static float PI = 3.14f;
4
5     public static int add(int a,int b){
6         return a+b;
7     }
8 }
 1 package cn.qd02;
 2
 3 // import cn.bd.Calc;
 4 // 静态导入
 5 import static cn.qd.Calc.*;
 6 public class Test01{
 7     public static void main(String[] args){
 8         System.out.println(PI);
 9         System.out.println(add(1,2));
10     }
11 }

2.继承

假如有两个类,dog类和cat类。它们都有相同的属性或方法,如String name,int weight等等。这时我们可以用继承,我们创建一个pet类,pet包含dog类和cat类相同的属性和类。让dog类和cat类继承pet类。

那么dog类和cat拥有pet类中的非私有的属性和方法。

这个公共的类称为父类(super class),继承于父类的类称为子类(sub class)。

java继承有两个特性:

1.单根性。在java中,一个类只能有一个直接父类。

2.传递性。C继承于B,B继承于A,C具有A的特性和行为。

2.1super

super关键字表示父类对象,只是一个关键字,里面没有引用。

super关键字用法:

【1】访问父类构造方法

1 public Dog(String name,int weight,int health,String stain){
2         super(name,weight,health);
3         this.setStrain(strain);
4 }        

super调用构造方法时,必须写在构造方法有效代码的第一句。

【2】调用父类非私有属性

1 public class Fruit{
2     float price;
3 }
 1 public class Apple extends Fruit{
 2
 3     public void showInfo(){
 4         // 不推荐使用
 5         //System.out.println("价格:"+price);
 6         //System.out.println("价格:"+this.price);
 7         // 当需要访问父类的属性时,优先使用super
 8         System.out.println("价格:"+super.price);
 9     }
10
11 }

【3】访问父类非私有方法

1 public void print(){
2         /*
3         System.out.print("我的昵称"+super.getName());
4         System.out.print(",健康值"+super.getHealth());
5         System.out.print(",体重"+super.getWeigh());
6         */
7         super.showInfo();
8         System.out.println(",我是一只"+this.getStrain());
9     }

2.2子类继承父类的资源

以下情况是,父类不能被继承的成员

1.private成员

2.构造方法

3.子类和父类不在同一个包下,使用默认修饰符的成员

3.访问修饰符

访问修饰符共有4种,private,默认,protect,public.


修饰符


本类?


同包子类


同包其他类


不同包子类


不同包其他类


private


?


?


?


?


?


默认


?


?


?


?


?


protected


?


?


?


?


?


public


?


?


?


?


?

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

2.friendly/default:默认的,同包可访问,也称包访问权限。

3.proteck:受保护的, ①子类可访问 ②同包可访问

4.pulic:公共的,都可以访问

4.继承关系的初始化顺序

继承关系内存图

5.方法的重写

当子类从父类继承过来的方法不能满足自身需要时,子类可以根据自身情况进行方法重写(overwrite/override)

方法重写建立在继承的基础上,没有继承,就没有重写!

方法重写,分为部分重写和全部重写,可视个人情况不同选择。

部分重写

1 public void showInfo(){
2         super.showInfo();
3         System.out.println("我是一只"+this.getStrain());
4     }

全部重写

1 public void showInfo(){
2         System.out.println("--"+super.getName()+"--");
3         System.out.println("健康值:"+super.getHealth());
4         System.out.println("体重:"+super.getWeight());
5         System.out.println("品种:"+this.getStrain());
6     }

重写的规则

[1]方法名称相同

[2]参数列表相同

[3]子类的访问权限一定 >= 父类访问权限

[4]返回值和父类相同或者是其子类,如下。

1 public Pet create(){
2         Pet pet = new Pet();
3         return pet;
4 }
1 public Dog create(){
2         Dog dog = new Dog();
3         return dog;
4 }

原文地址:https://www.cnblogs.com/qq308015824/p/10753413.html

时间: 2024-11-05 18:35:37

package,继承,访问修饰符的相关文章

PHP 类的继承 访问修饰符 重写

类的继承: 某些类A具有的某些特性,另一个类B,也具有A类的所有特性并且也有自己的特性,此时我们就可以实现B类使用A类的特性信息并继续添加自己的一些特有的特征信息  关键字是:extends基本概念:   继承:一个类从另一个已有的类获得其特性,称为继承   派生:从一个已有的类产生一个新的类,称为派生   也可以理解为:已有类为父类,新建类为子类,父类也叫基类,子类也叫派生类   一个类只能从一个上一级类继承其特性 叫单继承   多继承的话 就是继承他父类的父类 也就是爷爷类访问(权限)修饰符

java:包、继承,访问修饰符

包 包(package) 用于管理程序中的类,主要用于解决类的同名问题.包可以看出目录. 包的作用 [1] 防止命名冲突. [2] 允许类组成一个单元(模块),便于管理和维护 [3] 更好的保护类.属性和方法  包命名规范 包命名原则:始终保持类的全路径唯一. 规范: [1]包名由小写字母组成,不能以圆点开头或结尾.圆的有特殊意义——包分隔符 [2]包名之前最好加上唯一的前缀,通常使用组织倒置的网络域名.如:域名javagroup.net package net.javagroup.xx [3]

【2017-04-14】命名空间、访问修饰符、封装、继承、多态

一.命名空间 namespace 命名空间名称 如果命名空间一致,才能在他下面访问那些不同的类,如果不一致是没有办法直接访问的. 不同命名空间下都是public访问修饰符,想要调用,得在using处引用命名空间 using .... 是引用的命名空间 二.访问修饰符(写在命名任何东西的最前面) public    公共的,访问权限最高 private    私有的,访问权限最低,只能在类的内部进行访问 protected   被保护的,当前类及他的派生类中进行访问 internal    默认的

6.18 (继承+(四类访问修饰符+程序集+静态方法))提纲

继承: 一.什么是继承 概念:父亲有的东西,并且允许继承,所有孩子就都会有 一个父类可以拥有多个子类 一个子类只能拥有一个父类 二.父子之间的转换 子类可以转换成父类,这个父类只能转换成之前的子类 子类之间不可相互转换 ----------------------------------------------------------------------------- 1.访问修饰符: 对于跨类访问的一个权限限制 public : 公共的,引用命名空间即可随意访问,最高访问权限. priva

20151024_004_C#基础知识(C#中的访问修饰符,继承,new关键字,里氏转换,is 和 as,多态,序列化与反序列化)

1:C#中的访问修饰符 public: 公共成员,完全公开,没有访问限制. private: 私有的,只能在当前类的内部访问. protected: 受保护的,只能在当前类的内部以及该类的子类中访问. internal: 只能在当前项目中访问,在同一个项目中,internal和public的权限是一样的. protected internal: protected + internal权限. 1.1:能够修饰类的访问修饰符只有两个: public / internal 1.2:接口中的成员不允许

【2017-4-14】访问修饰符 封装 继承 多态

1.命名空间/程序集 2.访问修饰符public 公共的 - 访问权限是最高的private 私有的 - 只能在类的内部进行访问 internal 默认的 - 当前命名空间(程序集)下可以访问protected 被保护的 - 当前类及它的派生类中可以访问 3.封装private 数据类型 _名称; //成员变量,字段public 数据类型 名称 //属性{ get{ return _名称; } set{ _名称 = value; }} 还可以有方法 //成员方法 4.继承: 子类:父类一个子类只

面向对象的过程、继承、封装、多态;抽象类、访问修饰符的使用、引用类型强制转换、方法重写@override与重载、空指针异常、super关键字

面向对象设计的过程:     发现类-发现类的属性-发现类的方法-优化设计: 封装: private类型的,只可以在本类中使用,当其他类调用此类时,不可使用,因此可以设置setget方法,如下所示: 构造------------------------ 默认有无参构造,若设置了有参构造,则就没有默认的无参构造了,需要自己再添加一个 方法重载------------------- 方法名相同,参数列表不同(类型,数量,顺序不同,与参数名无关): 与返回值,访问修饰符无关 面向对象(OO)的优点--

访问修饰符和继承

访问修饰符: 访问修饰符是对于跨类访问的一个权限限制 public : 公共的,引用命名空间即可随意访问,最高访问权限.private : 私有的,只有在声明它的类和结构中才可以访问,访问权限最低. Internal : 内部的,同一个程序集中所有的类都可以访问,程序集就是命名空间.Protected : 受保护的,只能在他自己和自己的子类中才能访问. 继承: 父类有且允许子类继承的东西子类都会有,一个父类可以有多个子类,一个子类只能有一个父类. class Bird : Fly//前面是子类,

访问修饰符、封装、继承

一.访问修饰符:1.pubulc:公共的,只要引用了命名空间,就可以随意进行访问     *常用 2.private:私有的,只有当前类内部才可以访问        *常用 3.internal:内部的,当前程序集内可以访问,程序集就是命名空间,此修饰符是默认的 4.protected:被保护的,当前类和它的子类才可以访问 二.命名空间: 也叫程序集,项目中每一个文件夹都是一个独立的命名空间 如果要使用某一个命名空间下的类文件,那么必须首先引用此命名空间 三.封装 打包,封起来,保护起来 pub