java继承编程

A. java编程的继承属性和构造方法的执行

new B();//执行过程如下：

1. new，JVM为B类的对象分配内存
   

2. 调用B的构造方法，执行初始化。

3. B的构造方法自动调用父类的无参构造方法（编译器会在子类的构造方法的第一行插入父类的无参构造方法）

4. 父类A的构造方法中调用了方法setI(20);//此处是关键，new B();不会创建父类对象，调用父类构造方法只是用来执行父类中的初始化代码，不是创建对象，创建对象是new关键字，构造方法只是初始化，这里可能很难理解，不过这是JVM执行的方式，也是new关键字的作用。

5. 所以，父类A构造方法中调用的是子类的setI，不是父类的setI。整个过程中只有一个对象——B类的对象
   

B. java程序继承

packageextend;

/**
*圆类
*@author枫雅
*2019年3月21日
*/
publicclassCircle{
	privatedoubler;
	publicfinalstaticdoublePI=3.14;
	publicCircle(doubler){
		this.r=r;
	}
	
	publicdoubleCircumference(doubler){
		return2*PI*r;
	}
	
	publicdoubleArea(doubler){
		returnPI*r*r;
	}
}

packageextend;

/**
*圆柱类，继承自圆类
*@author枫雅
*2019年3月21日
*/
{

	privatedoubleh;
	publicCylinder(doubler,doubleh){
		super(r);
		this.h=h;
	}

	publicdoubleCeArea(doubler,doubleh){
		returnsuper.Circumference(r)*h;
	}
	
	publicdoubleVolume(doubler,doubleh){
		returnsuper.Area(r)*h;
	}
}

packageextend;

/**
*圆锥类，继承自圆柱类
*@author枫雅
*2019年3月21日
*/
{

	publicCone(doubler,doubleh){
		super(r,h);
	}

	publicdoubleCeArea(doubler,doubleh){
		returnsuper.CeArea(r,h)/2;
	}

	publicdoubleVolume(doubler,doubleh){
		returnsuper.Volume(r,h)/3;
	}
}

packageextend;

/**
*测试类
*@author枫雅
*2019年3月21日
*/
publicclassTest{

	publicstaticvoidmain(String[]args){
		doubler=3;
		doubleh=2;
		Circlecircle=newCircle(r);
		System.out.println("半径为："+r+"圆的周长为："+circle.Circumference(r));
		System.out.println("半径为："+r+"圆的面积为："+circle.Area(r));
		
		Cylindercylinder=newCylinder(3,2);
		System.out.println("底部半径为："+r+"，高为："+h+"圆柱的侧面积为："+cylinder.CeArea(r,h));
		System.out.println("底部半径为："+r+"，高为："+h+"圆柱的体积为："+cylinder.Volume(r,h));
		
		Conecone=newCone(3,2);
		System.out.println("底部半径为："+r+"，高为："+h+"圆锥的侧面积为："+cone.CeArea(r,h));
		System.out.println("底部半径为："+r+"，高为："+h+"圆锥的体积为："+cone.Volume(r,h));
	}

}

C. java编程 继承关系

/*
* 定义交通工具，汽车，火车，飞机这些类，注意它们的继承关系，为这些类提供超出3个不同的构造器
*/
class Transport {

public Transport() {
}
}

class Bus extends Transport {

private String busName;

public Bus(String busName) {
this.busName = busName;
}
}

class Train extends Transport {

private String trainName;
private double trainSpeed;

public Train(String trainName, double trainSpeed) {
this.trainName = trainName;
this.trainSpeed = trainSpeed;
}
}

class Airplane extends Transport {

private String airplaneName;
private double airplaneSpeed;
private String Voyage;

public Airplane(String airplaneName, double airplaneSpeed, String Voyage) {
this.airplaneName = airplaneName;
this.airplaneSpeed = airplaneSpeed;
this.Voyage = Voyage;
}
}

D. 使用java继承机制编程有什么好处谈谈你的实践体会

更安全。
继承简化了人们对事物的认识和描述，能清晰体现相关类间的层次结构关系。继承提供了软件复用功能。这种做法能减小代码和数据的冗余度，大大增加程序的重用性。提供多重继承机制。出于安全性和可靠性的考虑，仅支持单重继承，而通过使用接口机制来实现多重继承。
Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。

E. 求编写一个Java类的继承程序

java基础，继承类题目：编写一个Java应用程序，该程序包括3个类：Monkey类、People类和主类 E

21．编写一个Java应用程序，该程序包括3个类：Monkey类、People类和主类

E。要求：

(1) Monkey类中有个构造方法：Monkey (String s)，并且有个public void speak()

方法，在speak方法中输出“咿咿呀呀......”的信息。

(2)People类是Monkey类的子类，在People类中重写方法speak(),在speak方法

中输出“小样的，不错嘛！会说话了！”的信息。

(3)在People类中新增方法void think()，在think方法中输出“别说话！认真思考！”

的信息。

(4)在主类E的main方法中创建Monkey与People类的对象类测试这2个类的功

能。、

复制代码
package zhongqiuzuoye;

public class Monkey {

Monkey(String s) //构造
{}

public void speak()
{
System.out.println("咿咿呀呀......");
}
}

F. 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 域是不可能的，因为它没有定义。
是否可以解决您的问题？

G. java编程 要用到继承的方法

代码如下。输入参数和计算结果都为整数。具体类型请自行修改。

importjava.util.Scanner;
publicclassTest{
	publicstaticvoidmain(String[]args){
		while(true){
			Shapeshape=showMenu();
			System.out.println("所选图形的周长为："+shape.getRound());
			System.out.println("所选图形的面积为："+shape.getArea());
			shape=null;
		}
	}
	publicstaticShapeshowMenu(){
		Shapeshape=null;
		System.out.println("请选择图形：");
		System.out.println("1圆2矩形3三角形9退出");
		intoption=Shape.getInput();
		switch(option){
		case1:
			shape=newCircle();
			break;
		case2:
			shape=newRectangle();
			break;
		case3:
			shape=newTriangle();
			break;
		case9:
			System.out.println("系统退出！");
			System.exit(0);
			break;
		default:
			System.out.println("选项不存在");
			shape=showMenu();
			break;
		}
		returnshape;
	}
}
abstractclassShape{
	/**
	*给图形的参数赋值。
	*@paramsc
	*/
	abstractvoidgetParam();
	/**
	*获取周长
	*@return
	*/
	abstractintgetRound();
	/**
	*获取面积
	*@return
	*/
	abstractintgetArea();
	/**
	*获取输入的参数
	*@paramsc
	*@return
	*/
	publicstaticintgetInput(){
		intx=Integer.MIN_VALUE;
		try{
			x=newScanner(System.in).nextInt();
			if(x<0){
				thrownewException();
			}
		}catch(Exceptione){
			System.out.println("输入错误，请重新输入");
			x=getInput();
		}
		returnx;
	}
}
//矩形
classRectangleextendsShape{
	privateintside1;
	privateintside2;
	publicRectangle(){
		getParam();
	}
	voidgetParam(){
		System.out.println("第一条边：");
		this.side1=getInput();
		System.out.println("第二条边：");
		this.side2=getInput();
	};
	intgetRound(){
		return2*(side1+side2);
	}
	intgetArea(){
		returnside1*side2;
	}
}
//圆形
classCircleextendsShape{
	privateintr;
	publicCircle(){
		getParam();
	}
	voidgetParam(){
		System.out.println("请输入半径：");
		this.r=getInput();
	}
	intgetRound(){
		return(int)(2*Math.PI*r);
	}
	intgetArea(){
		return(int)(Math.PI*r*r);
	}
}
//三角形
classTriangleextendsShape{
	privateintside1;
	privateintside2;
	privateintside3;
	publicTriangle(){
		getParam();
	}
	voidgetParam(){
		System.out.println("第一条边：");
		this.side1=getInput();
		System.out.println("第二条边：");
		this.side2=getInput();
		System.out.println("第三条边：");
		this.side3=getInput();
		if(!isTriangle()){
			System.out.println("无法构成三角形，请重新输入");
			getParam();
		}
	}
	intgetRound(){
		returnside1+side2+side3;
	}
	intgetArea(){
		System.out.println("三角形面积计算稍显复杂，请自行写代码。");
		return0;
	}
	privatebooleanisTriangle(){	//根据两边之和大于第三边判断是否能构成三角形
		returnside1+side2>side3&&side1+side3>side2&&side2+side3>side1;
	}
}

H. java编程：（二）类的继承

public class DogTest {

public static void main(String[] args) {
Dog dog = new Dog("Mimi ", "3");
dog.setNickname("Baby");
System.out.println(dog.name + "is" + dog.age + " years old");
System.out.println("It’s nickname is " + dog.getNickname());

Animal animal = new Animal("Tom ", "3");
System.out.println(animal.name + animal.run());
}

}

/**
*
*/
package test;

/**
* @author lilin
*
*/
public class Dog extends Animal {

public Dog(String name, String age) {
super(name, age);
}

private String nickname;

public String getNickname() {
return nickname;
}

public void setNickname(String nickname) {
this.nickname = nickname;
}

public String run() {
System.out.println("run by four feet");
return null;
}

}

/**
*
*/
package test;

/**
* @author lilin
*
*/
public class Animal {

protected String name;

protected String age;

public Animal(String name, String age) {
this.name = name;
this.age = age;
}

public String run() {
return "can run";
}

}

I. 简单的java 编程题 关于继承

package javaapplication4;
public class Rect {
protected int length;/////这个地方不能变成私有属性，因为后面继承的类也需要继承它。
protected int width;
public Rect(int length,int width)
{
this.length=length;
this.width=width;
}
public void setLength(int length)
{this.length=length;<br> }
public void setWidth(int width)
{this.width=width;<br> }
public int getLength()
{return length;<br> }
public int getWidth()
{return width;<br> }
public int getArea()
{return length*width;<br> }
public int getCycle()
{return (length+width)*2;<br> }}
////////////////////////////////////////////////////////////////////////////////////////////////////////
package javaapplication4;
public class PlainRect extends Rect
{///此类并未继承父类的长宽属性，所以父类的设计是不合理的。应将其属性改为protected.
protected int startX,startY;
public PlainRect(int length,int width,int startx,int starty)
{
super(length,width);
startX=startx;
startY=starty;
}
public PlainRect()
{
super(0,0);
startX=0;
startY=0;
}
public boolean isInside(double x,double y)
{
boolean b=false;
if(x>startX&&x<startX+length)
if(y>startY&&y<startY+width)
b=true;
return b; }}
////////////////////////////////////////////////////////////////////////////////////////////////////////
package javaapplication4;
public class Main {
public static void main(String[] args) {
PlainRect Pr1=new PlainRect(20,10,10,10);
System.out.println("面积为："+Pr1.getArea());
System.out.println("周长为："+Pr1.getCycle());
System.out.println("点（25.5，13）"+(Pr1.isInside(25.5, 13)?"在":"不在")+"此方形内");
} }

J. 类的继承的java编程

class user
{
String name,id;
static int count=0;
user()
{
name="zhangsan";
id="123456";
count++;
}
user(String n)
{
name=n;
count++;
}
user(String n,String i)
{
name=n;
id=i;
count++;
}
void setId(String i){
id=i;
}
String getName(){
return name;
}
String getId(){
return id;
}
int getCount(){
return count;
}
void massage(){
System.out.println("用户名为："+getName());
System.out.println("用户口令为："+getId());
System.out.println("此为第"+getCount()+"个用户");
}
}
class useryy{
public static void main (String args[]){
user user1=new user();
user1.massage();
user user2=new user("lisi");
user2.setId("456123");
user2.massage();
user user3=new user("xiaozhang","456985");
user3.massage();
}
}