「java分析问题怎么做」java开发常见问题总结
今天给各位分享java分析问题怎么做的知识，其中也会对java开发常见问题总结进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
- 1、最简单的JAVA问题详细的分析以下
- 2、JAVA代码分析问题!
- 3、可以帮我分析下JAVA问题么？？
- 4、java异常问题 下面问题怎么做
- 5、关于java语法分析的问题
- 6、跪求高手用JAVA分析并给出以下问题的程序代码
最简单的JAVA问题详细的分析以下
答案
a=1b=1c=1
a=2b=2c=1
a=3b=1c=1
a=4b=2c=1
先看 a
它前面有个static 所以它是类变量，与类变量无关，相当于C++里面的全局变量，它会自动初始化为零，即使没有定义变量也可能通过 类名.a 来访问，所以它不会随着你定义两个变量（var v1 = new var();var v2 = new var();）而重新初始化，所以每次打印的值都会加1，即a
1 1 1 1
再看 b
它前面没有任何关键字，所以它是默认成员变量，没有实例化对象时，它是没有内存空间的，每给它实例化一个对象，它就会为该对象开辟一块内存，存放属于它的b（且初始化为0） ，所以对于b 有两个值，即v1.b和v2.b(而v1.a和v2.a是一个值，它们所指的内存是同一块)所以 b
1 2 1 2
再看 c
它是函数内部的局部变量，每次调用函数，它都会被初始化为0，所以无论调用多少次函数，它的值都是1，所以 c
1 1 1 1
再就是println表示打印并换行，print只打印；
综上，楼上的两位，一位可能没有JAVA编译器 ^_^ (开个玩笑)
JAVA代码分析问题!
class Person {
public String name; //定义一个name属性
public String location; //定义一个location属性
Person(String name){ //定义一个构造方法，用于初始化name属性
this.name = name;
location = "beijing"; //初始化location属性
}
Person(String name,String location) { //重载一个构造方法，用于初始化name属性和location属性
this.name = name;
this.location = location;
}
public String info() { //定义一个方法，返回实例的属性信息
return "name:"+ name +"location:"+location;
}
}
class Teacher extends Person { //定义一个Teacher类,从Person继承
private String capital;
Teacher (String name,String capital) { //定义一个构造方法，用于初始化name和capital属性
this(name,"beijing",capital); //调用本类中定义的构造方法
}
Teacher (String n,String l,String capital){ //定义一个构造方法，用于初始Teacher类中的capital,name和location属性
super (n,l); //调用父类中的构造方法初始化name,location属性
this.capital = capital; //初始化Teacher类中的capital属性
}
public String info() { //重写父类中的info()方法，并且附加capital属性的信息
return super.info() + "capital" + capital; //返回Teacher的各个属性信息
}
}
class Student extends Person { // 定义一个Student类,从Person继承
private String school; //定义chool字段
Student(String name,String school) { //定义一个构造方法，用于初始化name和school属性
this(name,"beijing",school); //调用本类中定义的构造方法
}
Student(String n,String l,String school) { //定义一个构造方法，用于初始Student类中的school,name和location属性
super(n,l); //调用父类中的构造方法初始化name,location属性
this.school = school; //初始化Student类中的school字段
}
public String info() { /重写父类中的info()方法
return super.info() + "school:" + school; //返回Student类中各个字段或属性信息
}
}
public class Test { //定义Test主类，用于测试定义各个类
public static void main (String[] args) {
Person p1 = new Person("A"); //实例化Person类，调用构造器初始化name属性
Person p2 = new Person("B","shanghai"); //实例化Person类，调用构造器初始化name,location属性
Student s1 = new Student("C","s1"); //实例化Student类，调用构造器初始化name,school属性
Student s2 = new Student("C","shanghai","s2"); //实例化Student类,调用构造器初始化name,location,school属性
Teacher t1 = new Teacher("D","perfessor"); //实例化Teacher类，调用构造器初始化name,capital属性
System.out.println(p1.info()); //输出实例p1的属性信息
System.out.println(p2.info()); //输出实例p2的属性信息
System.out.println(s1.info()); //输出实例s1的属性信息
System.out.println(s2.info()); //输出实例s2的属性信息
System.out.println(t1.info()); //输出实例t1的属性信息
}
}
可以帮我分析下JAVA问题么？？
如果接口抽象类都要用到的话,我推荐的做法如下:
门是一个抽象类,下面分别有3个子类去继承这个门的抽象类.即继承父类的属性.
//新建一个抽象类Door
public abstract class Door
{
//门的属性定义
protect int length;
protect int width;
protect int height;
protect String color;
protect int weight;
protect String type;
//默认构造方法
public Door()
{
}
//重载构造方法
public Door(int len,int wid,int hei,String col,int wei,String type)
{
this.length = len;
this.width = wid;
this.height = hei;
this.color = col;
this.weight = wei;
this.type = type;
//显示结果
System.out.println("长"+this.length+"宽"+this.width+"高"+this.height+"颜色"+this.color+"重量"+this.weight+"型号"+this.type);
}
}
新建一个接口定义如下:
public interface Idoor
{
//开门是否有声音
public void openDoor();
//是否防盗
public void isSafe();
}
然后就可以开始编写继承和实现的类了.
这里为了不新建那么多类,我把测试类和子类分别都写在一块了.
//木门继承Door并且实现Idoor的接口
class MDoor extends Door implements Idoor
{
private String material; //子类木门特有的材料属性.
public MDoor(String info)
{
//子类调用父类的构造函数,即继承父类的属性.
super(10,20,30,"灰色",50,"小型木门");
this.material = info;
System.out.println("我的材料是"+this.material);
}
//子类实现Idoor接口
public void openDoor()
{
System.out.println("木门开的时候有响声");
}
public void isSafe()
{
System.out.println("木门不防盗");
}
}
//铁门继承Door并且实现Idoor的接口
class TDoor extends Door implements Idoor
{
public TDoor()
{
//子类调用父类的构造函数,即继承父类的属性.
super(11,22,33,"白色",150,"小型铁门");
}
//子类实现Idoor接口
public void openDoor()
{
System.out.println("铁门开的时候没响声");
}
public void isSafe()
{
System.out.println("铁门防盗");
}
}
//防盗门继承Door并且实现Idoor的接口
class FDoor extends Door implements Idoor
{
public FDoor()
{
//子类调用父类的构造函数,即继承父类的属性.
super(15,26,36,"蓝色",150,"大型防盗门");
}
//子类实现Idoor接口
public void openDoor()
{
System.out.println("防盗门开的时候没响声");
}
public void isSafe()
{
System.out.println("防盗门防盗");
}
//子类自有的特性
public void hasCatEye()
{
System.out.println("防盗门有猫眼");
}
public void hasLock()
{
System.out.println("防盗门有上下锁");
}
}
//测试类,用来运行程序的.
public class Test
{
//Main函数,程序起点.
public static void main(String[] arr)
{
//这里用的都是多态
//用Door父类型接收, 实力具体的子类
Door md = new MDoor("竹子"); //木门特有的属性
md.openDoor();
md.isSafe();
System.out.println("-----------------------------");
Door td = new TDoor();
td.openDoor();
td.isSafe();
System.out.println("-----------------------------");
Door fd = new FDoor();
fd.openDoor();
fd.isSafe();
//防盗门的自有特性
fd.hasCatEye();
fd.hasLock();
}
}
//这样就大功告成了,至于为什么这样做,那就是接口和抽象类的作用了.
//分析的时候先从属性看起,看它们的共同之处,如果有就把它们提取出来,
//放在一个抽象类里,这样所有的子类只要继承该抽象类就可以拥有这些公用属
//性了，上述用到了super();调用抽象类的构造方法,从而获取公用属性.
//属性看完了,再看行为(方法),通常把一系列对象具有相同行为的(方法)
//提取出来,
//放在接口里,实现类只要实现该接口就可以完成他们的行为.上述的防盗门
//除了具有防盗的方法和开门是否有声音的方法外,还具有自己的特有方法,
//这些特有的方法(即不公用的方法)可以自己来实现,不需要再提取到接口里//了.
//还有不明白的地方 MSN留言.
java异常问题 下面问题怎么做
你好！很高兴为你解答问题。
首先，你这样写，利用String[] args来传递参数，就得先用命令行运行你的程序。
打开命令行，进入你项目所在根文件夹，输入命令 java Thirteen.NestedException 4
这里，4只是一个例子参数。这样，还是会抛异常。
原因在于，String args[]=null;
int num = Integer.parseInt(args[1]);
这里会抛java.lang.NullPointerException，因为你定义了args[]，初始化为null
下面一句，num就等于这个args[]数组第二个元素强制转换为整数的一个整数，而args[]数组是null，还没进行实例化，何来数据呢？当然会抛NullPointerException啦。
第二，如果解决了上面这个问题，你的代码是没有问题的。
最后，我帮你稍微修改了一下。
*************************代码如下***************************
package Thirteen;
/**
*
* @author 叶科良
*/
public class NestedException {
/* 构造方法。 */
protected NestedException() {
}
/** 这个方法检测数字的格式。
* @param argument 用于存储 args 的值。
*/
public void test(String string) {
try {
// String args[] = null;
// int num = Integer.parseInt(args[1]);
/* 嵌套 try 块。 */
String[] args = new String[5];
args[0] = string;
try {
int numValue = Integer.parseInt(args[0]);
System.out.println(args[0] + "的平方是 " + numValue * numValue);
} catch (NumberFormatException nb) {
System.out.println("不是一个数字！ ");
}
} catch (ArrayIndexOutOfBoundsException ne) {
System.out.println("请输入数字！！！");
}
}
/**main方法*/
public static void main(String[] args) {
NestedException obj = new NestedException();
obj.test(args[0]);
}
}
有问题可以追问！
关于java语法分析的问题
一个方法就表示一个迁移函数，一个判断就出现两种状态，不过循环之类的不好用 DFA 或者 NFA 表示的，因为里面有变量。这种复杂的语法还是用上下文无关文法吧。
另外我也有自动机一学期的课件，要的话我也给你发过去吧。
跪求高手用JAVA分析并给出以下问题的程序代码
我只会用 c 和c++ 来搞
#includestdio.h
#includeconio.h
void main()
{ int i;
for(i=1;i100;i++)
{
int n,R,i=0,a[16]=;
char str[17]="0123456789ABCDEF";
printf("\nplease input an integer number:\n");
scanf("%d",n);
printf("please input R:\n");
scanf("%d",R);
if(n0)
{
printf("%c",'-');
n=-n;
}
while(n!=0)
{
a[i++]=n%R;
n=n/R;
}
while(i--0)
printf("%c",str[a[i]]);
getche();
}
}
java分析问题怎么做的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java开发常见问题总结、java分析问题怎么做的信息别忘了在本站进行查找喔。