「java继承的实例变量」java 继承例子
本篇文章给大家谈谈java继承的实例变量，以及java 继承例子对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
- 1、java 中，什么是实例变量(Instance Variables)
- 2、java里类变量和实例变量的区别
- 3、在JAVA中什么是实例变量
- 4、JAVA继承实例
- 5、实例变量的java中的实例变量：
- 6、JAVA中成员变量、局部变量、实例变量、类变量之间有什么关系？
java 中，什么是实例变量(Instance Variables)
实例变量就是实例化该类对象才调用的非静态变量！
class A{
int i;//实例变量
public void mack() {
int m =1;//局部变量
}
}
单你new 一个A的对象的时候！对象就会在内存中为i分配一个内存！你就可以调用该变量！单你调用mack方法时候才会为m分配内存进行调用！
java里类变量和实例变量的区别
每次创建一个类的对象的时候，系统为它创建了类的每一个实例变量的副本。我们就可以从对象中访问该实例变量。
类变量或说静态变量跟实例变量是不一样的，不管为一个类创建了多少个对象，系统只为每个类变量分配一次存储空间。系统为类变量分配的内存是在执行main方法时马克-to-win， 就是在程序最最开始的时候（见下面StaticDemo的例子）。所有的对象共享了类变量。可以通过对象或者通过类本身来访问类变量。
Static fields
A field define as static, means there is only one such field shared by all objects
Instance fields
A field define without static, means each object has its own copy of fields
顺便提一句：通常用下面的形式，定义类的常量。（类或实例都可以访问）
static final double PI=3.14159;
静态方法（方法前冠以static）和实例方法（前面未冠以static）的区别
调用静态方法或说类方法时，可以使用类名做前缀，也可以使用某一个具体的对象名；通常使用类名。
非static的方法是属于某个对象的方法，而static的方法是属于整个类的，不被任何一个对象单独拥有；
由于static方法是属于整个类的，所以它不能操纵和处理属于某个对象的成员变量，而只能处理属于整个类的成员变量，也即，static方法只能处理static域或静态方法。实例方法可以访问实例域， 静态域或静态方法， 记住都行。
声明为static的方法有以下几条限制： 1.它们仅能调用其他的static方法。
2.它们只能访问static数据。
3.它们不能以任何方式引用this或super（关键 字super与继承有关，在下一章中描述）。
static method Have No this Reference
All instance methods have a hidden parameter—this
So,
Static
method can’t access instance methods and fields; it can only invoke
other static class members.It can access class members only.
instance can use static method.
Instance methods:
If a method is declared without the static modifier keyword,
that method is known as an instance method. Instance methods
are associated with objects – not classes.
It can access either instance or class members.
class StaticExa {
static int a = 4;
static int b = 9;
static void call() {
System.out.println("a = " + a);//静态方法可以访问静态属性
}
}
public class Test {
static int c = 43;
public static void main(String args[]) {
/*刚运行到这一步时，debug观察，StaticExa.a的值就等于42，Test.c的值就等于43，
说明系统在我们的程序一开始时，就会给所有的类变量赋值。如果是对象参考， 就是null，
见photoshop的例子*/
System.out.println("开始观察StaticExa.a和Test.c");
详情网上找“马克-to-win”，参考他的网站或他的百度空间：java第2章的内容
在JAVA中什么是实例变量
在java变量分为实例变量和静态变量
方法实例方法和静态方法
如
class Example{
int data;//定义实例变量，也叫成员变量
public void method(){
.....
}
static int count = 0;//定义静变量
public static func(){ //静态方法
......
}
public void static main(String arg[]){
Example e = new Example();//实例化一个对象
e.data = 0;//若要调用实例变量，则必须通过对象e来调用
count++;//要调用静态变量，则在这里直接调用
//同样，实例方法和静态方法也是如此
}
}
如果要在其它类中调用实例变量，则用 类.对象.实例变量，(如果实例变量是public)
若调用静态方法，用 类.方法 调用。
实例变量和实例方法是 对象的属性，
而静态变量和静态方法是 类的属性。
JAVA继承实例
继承是面向对象编程技术的一块基石，因为它允许创建分等级层次的类。运用继承，你能够创建一个通用类，它定义了一系列相关项目的一般特性。该类可以被更具体的类继承，每个具体的类都增加一些自己特有的东西。在Java 术语学中，被继承的类叫超类（superclass ），继承超类的类叫子类（subclass ）。因此，子类是超类的一个专门用途的版本，它继承了超类定义的所有实例变量和方法，并且为它自己增添了独特的元素。
继承一个类，只要用extends 关键字把一个类的定义合并到另一个中就可以了。为了理解怎样继承，让我们从简短的程序开始。下面的例子创建了一个超类A和一个名为B的子类。注意怎样用关键字extends 来创建A的一个子类。
// A simple example of inheritance.
// Create a superclass.
class A {
int i, j;
void showij() {
System.out.println("i and j: " + i + " " + j);
}
}
class B extends A {
int k;
void showk() {
System.out.println("k: " + k);
}
void sum() {
System.out.println("i+j+k: " + (i+j+k));
}
}
class SimpleInheritance {
public static void main(String args[]) {
A superOb = new A();
B subOb = new B();
System.out.println("Contents of superOb: ");
superOb.showij();
System.out.println();
subOb.i = 7;
subOb.j = 8;
subOb.k = 9;
System.out.println("Contents of subOb: ");
subOb.showij();
subOb.showk();
System.out.println();
System.out.println("Sum of i, j and k in subOb:");
subOb.sum();
}
}
该程序的输出如下：
Contents of superOb:
i and j: 10 20
Contents of subOb:
i and j: 7 8
k: 9
Sum of i, j and k in subOb:
i+j+k: 24
像你所看到的，子类B包括它的超类A中的所有成员。这是为什么subOb 可以获取i和j 以及调用showij( ) 方法的原因。同样，sum( ) 内部，i和j可以被直接引用，就像它们是B的一部分。
尽管A是B的超类，它也是一个完全独立的类。作为一个子类的超类并不意味着超类不能被自己使用。而且，一个子类可以是另一个类的超类。声明一个继承超类的类的通常形式如下：
class subclass-name extends superclass-name {
// body of class
}
你只能给你所创建的每个子类定义一个超类。Java 不支持多超类的继承（这与C++ 不同，在C++中，你可以继承多个基础类）。你可以按照规定创建一个继承的层次。该层次中，一个子类成为另一个子类的超类。然而，没有类可以成为它自己的超类。
成员的访问和继承
尽管子类包括超类的所有成员，它不能访问超类中被声明成private 的成员。例如，考虑下面简单的类层次结构：
/* In a class hierarchy, private members remain private to their class.
This program contains an error and will not compile.
*/
// Create a superclass.
class A {
int i;
private int j; // private to A
void setij(int x, int y) {
i = x; j = y;
}
}
// A"s j is not accessible here.
class B extends A {
int total; void sum() {
total = i + j; // ERROR, j is not accessible here
}
}
class Access {
public static void main(String args[]) {
B subOb = new B();
subOb.setij(10, 12);
subOb.sum();
System.out.println("Total is " + subOb.total);
}
}
该程序不会编译，因为B中sum( ) 方法内部对j的引用是不合法的。既然j被声明成private，它只能被它自己类中的其他成员访问。子类没权访问它。
注意：一个被定义成private 的类成员为此类私有，它不能被该类外的所有代码访问，包括子类。
更实际的例子
让我们看一个更实际的例子，该例子有助于阐述继承的作用。新的类将包含一个盒子的宽度、高度、深度。
// This program uses inheritance to extend Box.
class Box {
double width; double height; double depth;
// construct clone of an object
Box(Box ob) { // pass object to constructor
width = ob.width;
height = ob.height;
depth = ob.depth;
}
// constructor used when all dimensions specified
Box(double w, double h, double d) {
width = w;
height = h;
depth = d;
}
// constructor used when no dimensions specified
Box() {
width = -1; // use -1 to indicate
height = -1; // an uninitialized
depth = -1; // box
}
// constructor used when cube is created
Box(double len) {
width = height = depth = len;
}
// compute and return volume double
volume() {
return width * height * depth;
}
}
BoxWeight extends Box {
double weight; // weight of box
// constructor for BoxWeight
BoxWeight(double w, double h, double d, double m) {
width = w;
height = h;
depth = d;
weight = m;
}
}
class DemoBoxWeight {
public static void main(String args[]) {
BoxWeight mybox1 = new BoxWeight(10, 20, 15, 34.3);
BoxWeight mybox2 = new BoxWeight(2, 3, 4, 0.076);
double vol;
vol = mybox1.volume();
System.out.println("Volume of mybox1 is " + vol);
System.out.println("Weight of mybox1 is " + mybox1.weight);
System.out.println();
vol = mybox2.volume();
System.out.println("Volume of mybox2 is " + vol);
System.out.println("Weight of mybox2 is " + mybox2.weight);
}
}
该程序的输出显示如下：
Volume of mybox1 is 3000.0
Weight of mybox1 is 34.3
Volume of mybox2 is 24.0
Weight of mybox2 is 0.076
BoxWeight 继承了Box 的所有特征并为自己增添了一个weight 成员。没有必要让BoxWeight 重新创建Box 中的所有特征。为满足需要我们只要扩展Box就可以了。
继承的一个主要优势在于一旦你已经创建了一个超类，而该超类定义了适用于一组对象的属性，它可用来创建任何数量的说明更多细节的子类。每一个子类能够正好制作它自己的分类。例如，下面的类继承了Box并增加了一个颜色属性：
// Here, Box is extended to include color.
class ColorBox extends Box {
int color; // color of box
ColorBox(double w, double h, double d, int c) {
width = w;
height = h;
depth = d;
color = c;
}
}
记住，一旦你已经创建了一个定义了对象一般属性的超类，该超类可以被继承以生成特殊用途的类。每一个子类只增添它自己独特的属性。这是继承的本质。
超类变量可以引用子类对象
超类的一个引用变量可以被任何从该超类派生的子类的引用赋值。你将发现继承的这个方面在很多条件下是很有用的。例如，考虑下面的程序：
class RefDemo {
public static void main(String args[]) {
BoxWeight weightbox = new BoxWeight(3, 5, 7, 8.37);
Box plainbox = new Box(); double vol;
vol = weightbox.volume();
System.out.println("Volume of weightbox is " + vol);
System.out.println("Weight of weightbox is " + weightbox.weight);
System.out.println();
// assign BoxWeight reference to Box reference
plainbox = weightbox;
vol = plainbox.volume(); // OK, volume() defined in Box
System.out.println("Volume of plainbox is " + vol);
/* The following statement is invalid because plainbox does not define a weight member. */
// System.out.println("Weight of plainbox is " + plainbox.weight);
}
}
这里，weightbox 是BoxWeight 对象的一个引用，plainbox 是Box对象的一个引用。既然BoxWeight 是Box的一个子类，允许用一个weightbox 对象的引用给plainbox 赋值。
当一个子类对象的引用被赋给一个超类引用变量时，你只能访问超类定义的对象的那一部分。这是为什么plainbox 不能访问weight 的原因，甚至是它引用了一个BoxWeight 对象也不行。仔细想一想，这是有道理的，因为超类不知道子类增加的属性。这就是本程序中的最后一行被注释掉的原因。Box的引用访问weight 域是不可能的，因为它没有定义。
实例变量的java中的实例变量：
实例变量：定义在类中但在任何方法之外。（New出来的均有初始化）
当一个对象被实例化之后，每个实例变量的值就跟着确定；
实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
实例变量可以声明在使用前或者使用后；
访问修饰符可以修饰实例变量；
实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。 局部变量：定义在方法之中的变量。
1. 局部变量要先赋值，再进行运算，而实例变量均已经赋初值。（这是局部变量和实例变量的一大区别）
2. 实例变量的对象赋值为null。
3. 局部变量不允许范围内定义两个同名变量。实例变量的作用域在本类中完全有效，当被其他的类调用的时候也可能有效。
4. 实例变量和局部变量允许命名冲突。 public class Sample
{
private int a=1; //实例变量
public void b()
{
int a=2; //局部变量
System.out.println(局部变量:a=+a);
System.out.println(实例变量:a=+this.a);//局部变量的作用域内引用实例变量:this.变量名
}
public static void main(String[] args)
{
new Sample().b();
}
}
运行输出：
局部变量：2
实例变量；1
JAVA中成员变量、局部变量、实例变量、类变量之间有什么关系？
java易混淆概念之类变量、实例变量、局部变量
类变量、实例变量、局部变量类变量是类中独立于方法之外的变量，用static 修饰。
实例变量也是类中独立于方法之外的变量，不过没有static修饰。
局部变量是类的方法中的变量。
Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。
JDK（Java Development Kit）称为Java开发包或Java开发工具，是一个编写Java的Applet小程序和应用程序的程序开发环境。JDK是整个Java的核心，包括了Java运行环境（Java Runtime Envirnment），一些Java工具和Java的核心类库（Java API）。
Java看起来设计得很像C++，但是为了使语言小和容易熟悉，设计者们把C++语言中许多可用的特征去掉了，这些特征是一般程序员很少使用的。例如，Java不支持go to语句，代之以提供break和continue语句以及异常处理。Java还剔除了C++的操作符过载（overload）和多继承特征，并且不使用主文件，免去了预处理程序。
关于java继承的实例变量和java 继承例子的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。