java编程问题
public class Card {
private String num;
private String name;
private String sex;
private String birth;
public String getBirth() {
return birth;
}
public void setBirth(String birth) {
this.birth = birth;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getNum() {
return num;
}
public void setNum(String num) {
this.num = num;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
}
---------------------------------------
public class TeacherCard extends Card{
private String work;
private String date;
public String getDate() {
return date;
}
public void setDate(String date) {
this.date = date;
}
public String getWork() {
return work;
}
public void setWork(String work) {
this.work = work;
}
}
-----------------------------------------
public class StudentCard {
private String department;
private String time;
private String message;
public String getDepartment() {
return department;
}
public void setDepartment(String department) {
this.department = department;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public String getTime() {
return time;
}
public void setTime(String time) {
this.time = time;
}
}
--------------------------------
public abstract class Person {
public abstract double pay();
}
---------------------------------
public class Teacher extends Person implements Pay{
private double basePay;
private double hour;
private TeacherCard teacherCard;
public double pay() {
return this.basePay + this.hour * 30;
}
public double getBasePay() {
return basePay;
}
public void setBasePay(double basePay) {
this.basePay = basePay;
}
public double getHour() {
return hour;
}
public void setHour(double hour) {
this.hour = hour;
}
public TeacherCard getTeacherCard() {
return teacherCard;
}
public void setTeacherCard(TeacherCard teacherCard) {
this.teacherCard = teacherCard;
}
}
----------------------------------
public class CollegeStudent extends Person{
private double outPay;
private StudentCard studentCard;
public double getOutPay() {
return outPay;
}
public void setOutPay(double outPay) {
this.outPay = outPay;
}
public StudentCard getStudentCard() {
return studentCard;
}
public void setStudentCard(StudentCard studentCard) {
this.studentCard = studentCard;
}
public double pay() {
return outPay;
}
}
------------------------------
public interface Pay {
public double pay();
}
-----------------------------
public class Test {
public static void main(String[] args) {
Person pp = new Teacher();
((Teacher) pp).setBasePay(2000);
((Teacher) pp).setHour(3);
System.out.println(pp.pay());
pp = new CollegeStudent();
((CollegeStudent) pp).setOutPay(500);
System.out.println(pp.pay());
}
}
//一共8个类，我测试过了，不懂问我~
⑵ JAVA编程问题
第一个问题比较简单 告诉你思路吧
两个用同名方法 参数不同 那就是用到了 函数方法中的重载，
然后 数握雀组的复制 就是先将数组转成集合 利用 Arrays.asList()方法
然后就可以利用集合的增删改查操作数组中的元扒游素，可以实现复制的目的，
还有 Collection.toArray()方法 还可以将数组转回数组，很简单的
至于0-1000的随机数 更好说了，，
类Random.nextInt(1)*1000 就OK了
第二个问题的答案 代码 写在下面：
import java.util.*;
public class MathWork1 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int x=sc.nextInt();
int y=sc.nextInt();
System.out.println(getYue(x,y));
System.out.println(getBei(x,y));
}
public static int getYue(int x,int y)
{
ArrayList<Integer> al1=new ArrayList<Integer>();
ArrayList<Integer> al2=new ArrayList<Integer>();
for(int i=2;i<=x;i++){
if(x%i==0)
al1.add(i);
}
for(int i=2;i<春皮销=y;i++){
if(y%i==0)
al2.add(i);
}
al1.retainAll(al2);
if(al1!=null)
return al1.get(al1.size()-1);
else return 1;
}
public static int getBei(int x,int y)
{
ArrayList<Integer> al1=new ArrayList<Integer>();
ArrayList<Integer> al2=new ArrayList<Integer>();
boolean flag=false;
for(int i=2;i<=x;i++){
if(x%i==0)
al1.add(i);
}
for(int i=2;i<=y;i++){
if(y%i==0)
al2.add(i);
}
al1.retainAll(al2);
if(al1.size()==1)
return x*y/al1.get(0);
if(al1!=null)
{
int b=0;
for(int i=0;i<al1.size()-1;i++)
{
int a=al1.get(i+1);
b=al1.get(i);
b*=a;
}
return b;
}
else
return x*y;
}
}
⑶ 关于java编程的问题:一个类调用另一个类中构造方法中所定义的参数。
关于java编程的问题:一个类调用另一个类中构造方法中所定义的参数。 类中构造方法中所定义的参数一般是属于类的属性，都是定义为private的，所以无法直接获取或者操作类的属性，但是可以通过类的get和set方法，间接获取和操作类的属性。以下为set和get方法示范：<pre t="code" l="java">public int getA() {
return a;
}
public void setA(int a) {
this.a = a;
}
C#中结构中构造方法定义的问题
共同点:
都是实例化对象，初始化数据的
默认颂碧构造是说所有的类都从祖先object那继承了空参的构造方法，你不写与写空参构造都存在,而有参数的构造一般是自己写的，写就有不写就没有，它的作用和空参的一样，只是它里面可以有参数，给你个例子来说明吧
有一个类Monitor它有属性String height;String
width
public Monitor(){}
public Monitor(String height,String width){}
有一个空参的一个有参的构造的方法
在main方法里我做初始化动作
Monitor monitor=new Monitor();
这个构造只是把显示器这个对象创造出来了，它的属性就没有值,也可以再手动给它赋上值
如:monitor.height=100;
monitor.width=200;
用有参的就不一样了，少很多事
Monitor monitor2=new Monitor("100","200");
在这里我只要把想放进去的参数直接放进去就能给我的属性赋上值，是不是省了很多事?
这就是它的优势!
回答完结!
构造函数 是一种特殊的方法 主要用来在创建对象时初始化对象 即为对象成员变量赋初始值
总与new运算符一起使用在创建对象的语句中 特别的一个类可以有多个构造函数 可根据其参数个数的不同或参数类型的不同来区分它们 即构造函数的重载
构造函数与其他方法的区别
1.构造函数御手的命名必须和类名完全相同;而一般方法则不能和类名相同.
2.构造函数的功能主要用于在类的对象创建时定义初始化的状态.它没有返回值,也不能用void来修饰.这就保证了它不仅什么也不用自动返回,而且根本不能有任何选择.而其他方法都有返回值.即使是void返回值,尽管方法体本身不会自动返回什么,但仍然可以让它返回一些东西,而这些东西可能是不安全的.
3.构造函数不能被直接调用,必须通过new运算符在创建对象时才会自动调用,一般方法在程序执行到它的时候被调用.
4.当定义一个类的时候，通常情况下都会显示该类的构造函数,并在函数中指定初始化的工作也可省略不去Java编译器会提供一个默认的构造函数.此默认构造函数是不带参数野拆举的.而一般方法不存在这一特点
简单的来说构造函数就是用来创建对象用的，说的专业些叫实例化对象。
定义：
class A
{
public A(){}
}
使用：
A a=new A();在这里，A()就是就是构造函数。
需要注意的一点是，如果类里面没有定义构造函数，编译器也会自动生产一个空构造函数，类的各个成员都赋上默认值。
但是如果在类里面只定义了一个私有的构造函数的时候，那么这个类将不能被实例化。
class A
{
string a;
private A() { }这个类不能被实例化
}
如果我们定义了带参数的构造函数，而没有定义不带参数的构造函数，那么在实例化这个类的对象的时候必须提供参数。
class A
{
string a;
public A(string str) {a=str; }
}
不能这么实例化对象 A a=new A(); 构造函数分为动态构造函数和静态构造函数。
动态构造函数是类或结构实例化时，为其分配内存空间，完成类或结构当中成员变量的初始化工作。动态构造函数可以重载，即相同构造函数名称拥有不同类型和数目的多个构造函数。带参数的构造函数和不带参数的构造函数没有本质区别，带参数的构造函数可以通过传入的变量控制或者直接初始化其中的成员变量，在构造函数中可以为成员变量初始化默认值。
静态构造函数不允许携带参数，即一个类中只允许有一个静态构造函数。它在第一次访问静态成员或者第一次实例化动态该类的对象之前调用。
关于Java中构造方法的问题
可以，一般都用，单例用private
java中一个类想调用另一个类中定义的面板怎么调用
将主面板传递给一个类，在这个类中将主面板上的将你想要的面板一层一层剥下来，并获得它，然后在你想要的面板上做操作。
注意:主面板上放的是一个ponent数组
在类中的构造方法修改一变量,怎样在另一个类构造方法中调用这个变量的值java
public class Test
{
int a = 0;
public Test()
{
a = 1;
}
}
public class Test1
{
Test t;
public Test1()
{
t = new Test();
System.out.println(t.a);
}
public static void main(String args[])
{
new Test1();
}
}
急！Java编程：定义一个类用main方法和构造方法怎么写？
public class Dog{
String color;
Dog(String color) {
this.color=color;
}
public String toString() {
return "yellow dog";
}
public static void main() {
Dog d=new Dog("yellow");
System.out.println(d);
}
}
Java中构造方法何时被调用
新建一个对象时被调用。也就是new的时候；
如：
public class A{
int i;
String c;
public A(){ } 无参构造方法
public A(int i,String c)
{
this.i = i;
this.c = c;
}两参构造方法
public static void main(String[] args){
A a = new A() ;调用了无参构造方法；
A a1 = new A(5,"vieri");调用了两参构造方法
}
}
java 一个类中怎么调用另一个类方法中 变量
方法变量是局部变量,没办法访问,但是传出来!
public class 局部变量 { public static void main(String[] args) { System.out.println("\n\t\t==========局部变量==========\n"); init(); }初始化! private static void init() { int a=new A().show(); System.out.println(a);结果是10 }}测试类!class A{ int show() { int a=10; return a; }}
java类中构造方法可以私有化吗
您好，构造方法私有化，也就是说，这个类的构造方法是私有的。比如：
public class Person{
private String name；
Private Person（String Name）{ 私有的构造方法
this.name = name；
}
}
我们不能在外部实例化这个Person对象的类！
比如：
Public Class TestPerson{
public static void main(String args[]){
Person per = new Person(); 此步是错误的！因为你已经将person类的构造方法设置为
private 了
}
}
如果我们想在Person类的外部使用Person类的对象，只能在person类的内部实例化一个Person类的对象，然后调用这个对象，而不能再外部实例化新的对象。
public class Person{
private String name;
Private Person newPerson; Person类唯一的实例化对象
Private Person（String Name）{ 私有的构造方法
this.name = name;
}
newperson = new Person("网络知道");
Public Person getInstance(){ 将newperson返回给外部调用处！
return newperson;
}
}
外部的Person类的所有对象只能是对Person内部newperson对象的引用。
外部一千一万个对象也都只能是对Person内部newperson对象的引用。
因为外部定义的Person类对象没有实例化能力。这就是单例设计模式，从头至尾只有一个对象的实例（单例）
⑷ java编程的问题
分类汪祥: 电脑/网络 >> 程序设计 >> 其他编程语言
问题描述:
编写源文件
class A
{
【代码1】 声明一个float型实例变量：a
【代码2】宽猜 声明一个float型类变量：b
void setA(float a)
{
【代码3】 将参数a的值赋值给成员变量a
}
void setB(float b)
{
【代码4】 将参数b的值赋值给成员变量b
}
float getA()
{
return a;
}
float getB( )
{
return b;
}
void inputA( )
{
System.out.println(a);
}
static void inputB()
{
System.out.println(b);
}
public class sy4_2
{
public static void main(String args[])
{
【代码5】慎陵型 通过类名操作类变量b,并赋值100
【代码6】 通过类名调用方法inputB()
A cat=new A();
A dog=new A();
【代码7】 cat调用方法setA(int a)将cat的成员a的值设置为200
【代码8】 cat调用方法setB(int b)将cat的成员b的值设置为400
【代码9】 dog调用方法setA(int a)将dog的成员a的值设置为300
【代码10】 dog调用方法setB(int b)将dog的成员b的值设置为800
【代码11】 cat调用inputA()
【代码12】 cat调用inputB()
【代码13】 dog调用inputA()
【代码14】 dog调用inputB()
}
解析:
【代码1】:float a;
【代码2】:static float b;
【代码3】:this.a=a;
【代码4】:A.b=b;
【代码5】:A.b=100;
【代码6】:A.inputB();
【代码7】:cat.setA(200);
【代码8】:cat.setB(400);
【代码9】:dog.setA(300);
【代码10】:dog.setB(800);
【代码11】:cat.inputA();
【代码12】:cat.inputB();
【代码13】:dog.inputA();
【代码14】:dog.inputB();
⑸ JAVA编程问题
用下面的API创建一个“等级”类
构造函数
分数
int学生计数，int MINI等级，int Max等级）
这将创建一系列学生成绩。每个年级将是一个随带中机数从最小年级到最大年级，包括。
方法
1）toSTRIN（）
打印这种格式的等级：
等级：[ 78, 58, 76，101, 59, 55，84, 91, 84，67 ]
2）用于分级的存取器和多路选择器
3）等值法
4）克慧行橘隆方法
5）按升序排序等级的方法
6）按降序排列等级的方法
7）返回最高等级的方法
8）将平均成绩返回到小数点的方法。
9）返回中位数的方法。
10）返回模式的方法 。
11）返回一个数组，其中包含F的D的C的B和A的数目
〔7, 2, 1，0, 0〕
12）返回包含每个学生的字母等级的数组的方法
[f，f，d，f，f，c，f，f，d，f]
13）等级到一位小数的标准差
一、
有多少学生？
十
最小年级：
零
最大等级：
一百
等级：[ 59, 1, 70，1, 30, 7，48, 100, 45，83 ]
排序等级：[ 1, 1, 7，30, 45, 48，59, 70, 83，100 ]
反向等级：[ 100, 83, 70，59, 48, 45，30, 7, 1，前团1 ]
最高等级为：100。
平均成绩：44.4分
中位数：46
模式〔1〕
字母等级：[ 7, 0, 1，1, 1 ]
[f，f，c，f，f，f，f，a，f，b]
SD：32.9
克隆等级相等
品位变化：
一
新年级：
一百
等级：[ 59, 100, 70，1, 30, 7，48, 100, 45，83 ]
变年级不等于
有多少学生？
磷
有多少学生？
- 1
有多少学生？
零
有多少学生？
十一
最小年级：
一百零五
最大等级：
五十
等级：[ 56, 59, 92，94, 80, 55，103, 101, 78，51, 69 ]
排序等级：[ 51, 55, 56，59, 69, 78，80, 92, 94，101, 103 ]
反向等级：[ 103, 101, 94，92, 80, 78，69, 59, 56，55, 51 ]
最高等级为：103。
平均成绩：76.2分
中位数：78
模式〔51, 55, 56、59, 69, 78、80, 92, 94、101, 103〕
字母等级：[ 4, 1, 1，1, 4 ]
[f，f，a，b，f，a，a，c，f，d]
SD：18.5
克隆等级相等
品位变化：
九
新年级：
一百
等级：[ 56, 59, 92，94, 80, 55，103, 101, 78，100, 69 ]
变年级不等于
⑹ JAVA编程问题
public class Account{
private String accountName; //帐户名肢好
private double amount;//存款余额
//set get 方法省略
//存款方法
//synchronized 同步关键词 防止并发调用此方法
public static synchronized int deposit（Account account,double money）
{
if(account==null)return 0;
try{
double balance=account.getAmount()+money;
account.setAmount(balance);
}catch(Exception e)
{
System.out.println("出错信息:“+e.getMessage());
return 0;
}
return 1;
}
//取款方法
//synchronized 同步关键词 防止并发调用此方法
public static synchronized int withdraw(Account account,double money)
{
if(account==null)return 0;
try{
if(account.getAmount()>=money)
account.setAmount(account.getAmount()-money);
return 1;
}catch(Exception e)
{
System.out.println("出错信息:“+e.getMessage());
return 0;
}
}
}
//此类考虑了同步问题，但我觉得应该把存款，取款另起一个类实现散歼：帐户管理类，历掘铅此类管理所有的存，取款交易。
⑺ JAVA编程问题
不知道我对你的这段程序的理解是否正确，money为状态控制的变量，随着Money的变化AB线程的状瞎吵态发生变化。
想要达到这样的效果，那么你对money的操作就不能和AB在同个线程中，应该要另起一个线程专门来控制money的变化。消丛
下面的代码希望对你有帮助
class Runner implements Runnable {
public int money = 200;
public boolean flagA = true;
public boolean flagB = true;
public Thread A = new Thread(this, "A");
public Thread B = new Thread(this, "B");
public Runner() {
new Thread(this, "money").start();
A.start();
B.start();
}
public void run() {
String name = Thread.currentThread().getName();
while (name.equals("A") ? flagA : flagB) {
if (name.equals("A")) {
if (money >= 100) {
System.out.print("当前的money值为" + money);
System.out.println("当前运行磨桥侍的线程" + name);
} else {
flagA = false;
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if (name.equals("B")) {
if (money >= 60) {
System.out.print("当前的money值为" + money);
System.out.println("当前运行的线程" + name);
} else {
flagB = false;
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if (name.equals("money")) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
money -= 10;
}
}
}
}
⑻ java编程问题
class Person {
private String name;
private String sex;
private int age;
public Person() {
}
public Person(String name, String sex, int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void show() {
System.out.println("父类的name属性的值为："+name);
System.out.println("父类的sex属性的值御吵敬为："+sex);
System.out.println("父类的age属性的值为："+age);
}
}
class Student extends Person {
private String specialty;
private String banji;
private String studentId;
public Student(){
}
public Student(String name, String sex, int age,String specialty,String banji,String studentId){
super(name, sex, age);
this.specialty = specialty;
this.banji = banji;
this.studentId = studentId;
}
public String getSpecialty() {
return specialty;
}
public void setSpecialty(String specialty) {
this.specialty = specialty;
}
public String getBanji() {
return banji;
}
public void setBanji(String banji) {
this.banji = banji;
}
public String getStudentId() {
return studentId;
}
public void setStudentId(String studentId) {
this.studentId = studentId;
}
public void show() {
super.show();
System.out.println("子类的specialty属性的值为："+specialty);
System.out.println("子类镇慎的banji属性的值为："+banji);
System.out.println("子碰码类的studentId属性的值为："+studentId);
}
}
public class TestStudent {
public static void main(String[] args) {
Student student = new Student();
student.setName("小春");
student.setSex("女");
student.setAge(28);
student.setSpecialty("计算机");
student.setBanji("2班");
student.setStudentId("090223");
student.show();
}
}
⑼ java编程问题
以下代码在MyEclipse 6.0测试通过
GameDriver类
package com.ts;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class GameDriver {
/**
* @param args
* 实现跳跃规则找到最小的和的小游戏
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner k = new Scanner(System.in); //定义输入流
System.out.println("This propram plays the 'Jump It' game. ");
List<Integer>衫敏 board=new ArrayList<Integer>();//声明一个动态泛型数组
board.add(0);//默认第一个元素为0
///该循环实现连续提示用户输入数值并填充动态数组board
for (int i = 0; i <board.size()+1; i++)
{
System.out.print("Enter a positive number or 0 to stop?");
//没有对数据合法性进行验证
board.add(k.nextInt());
if(board.get(board.size()-1)==0)//判掘哗断动态数组最后一位是否为0
{
break;
}
}
System.out.print("This is the board: ");
//该循环实现遍历动态数组
for(int i=0;i<board.size()-1;i++)
{
System.out.print(board.get(i)+" ");
}
//打印换行
System.out.println("");
System.out.println("The lowest cost is: "+Game.cheapWay(board,0));
}
}
Game类
package com.ts;
import java.util.List;
public class Game {
/**
* @param args
* 该类实现游戏规则
*/
public static int cheapWay(List<Integer> list, int n)
{
if(list.size() - 1 == n)
return list.get(n);
else if(list.size() - 2 == n)
return list.get(n) + list.get(list.size() - 1);
else if(cheapWay(list, n + 1) <判塌行 cheapWay(list, n + 2))
return list.get(n) + cheapWay(list, n + 1);
else
return list.get(n) + cheapWay(list, n + 2);
}
}
--------------------------------------------------------
下次有问题发我QQ 121354340 大漠孤烟
星期一到星期五白天都在 备注 网络知道
⑽ Java编程问题
包名改成你自己的
packagetest;
publicclassStudent{
privateintno;
privateStringname;
privateintage;
privateintcount;
publicStudent(intno,Stringname,intage){
this.no=no;
this.name=name;
this.age=age;
count++;
}
publicintgetNo(){
returnno;
}
publicvoidsetNo(intno){
this.no=no;
}
publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
publicintgetAge(){
returnage;
}
publicvoidsetAge(intage){
基模this.age=age;
}
publicintgetCount(){
returncount;
}
publicvoidsetCount(intcount){
this.count=count;
}
@Override
publicStringtoString(){
return"学号："+no+"姓名："+name+"年龄："+age;
}
publicstaticvoidmain(String[]args){
核正Studentstu=newStudent(1,"zhangsan",22);
System.out.println(stu.toString());
stu.setName("lisi");
stu.setAge(25);
改锋悔System.out.println(stu.toString());
}
}