java一個類調用另一個類

❶ 關於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中怎麼在一個類中調用另一個類的全部方法

java類有兩種方法一種是類方法就是用static修雀襲圓飾的，一種是實例方法，就是沒有static修飾的方法。類方法可以同時類名.方法頃塌名的禪讓方式調用。而實例方法必須先生存類的實例在通過實例.方法名的方式調用。例如：

public class MethodCall
{
public static void main(String[] args)
{
Test.sayStatic();
Test test = new Test();
test.sayInstance();
}
}
class Test
{
public static void sayStatic()
{
System.out.println("這是一個靜態方法。");
}
public void sayInstance()
{
System.out.println("這是一個實例方法。");
}
}

❸ java 一個類調用另一個類的private方法

Java調用private方法利用的是Java中的類反射機制 。
定義一個class，定義一個內部private方法：
public class PrivateTest {
private void print() {
System.out.println("this is a private method");
}
}
再定義一個class去訪問剛才定義的private方法，也就是print()如下
import java.lang.reflect.Method;

public class PrivateTest2 {
public static void main(String[] args) {
try {
Method method = PrivateTest.class.getDeclaredMethod("print", new Class[]{});
method.setAccessible(true);
Method.invoke(new PrivateTest(), new Object[] {});
} catch (Exception ex) {
System.out.println(ex.toString());
}
}
}
利用java的反射機制,即使是private方法,也可以被調用使用。

❹ Java中的一個類怎麼調用另一個類中的方法

publicclass調用
{
publicstaticvoidmain(String[]args)
{
System.out.println(" ==========Java中的一個類怎麼調用另一個類中的方法!========== ");
init();
}//初始化!
privatestaticvoidinit()
{
//創建A類對象
Aa=newA();
a.show2();
a.show1();
System.out.println(" ------------------------------分割線-------------------------- ");
//創建B類對象
Bb=newB();
b.method1();
b.method2();
}
}
//A類!
classA
{
voidshow1()
{
System.out.println("這個是A類中的show1方法,調用B類的method1方法");
newB().method1();
}
voidshow2()
{
System.out.println("這個是A類中的show2方法!");
}
}
//B類!
classB
{
voidmethod1()
{
System.out.println("這個是B類中的method1方法!");
}
voidmethod2()
{
System.out.println("這個是B類中的method2方法!調用A類的show2方法");
newA().show2();
}
}

❺ java中一個類想調用另一個類的變數該怎麼辦

如果另一個類的變數是靜態變數，用 類名.變數名 調用
如果是public的變數，先創建另一個類的對象，用 對象名.變數名 調用
如果是private的變數，用set、get方法操作對象
還可以利用反射機制操作變數