java累

Ⅰ 關於java的問題：什麼是類寫出java中類定義的格式

類（Class）是面向對象程序設計（OOP，Object-Oriented Programming）實現信息封裝的基礎。類是一種用戶定義的引用數據類型，也稱類類型。每個類包含數據說明和一組操作數據或傳遞消息的函數。類的實例稱為對象。

定義一個類的格式如下圖：

(1)java累擴展閱讀：

對象可以訪問類的成員，但並不是所有成員都可以被訪問，能否訪問取決於聲明該成員時所用的關鍵字（public/protected/private）。具體規則如下：

1、類的公有成員可以被該類，其派生類和類實例化的對象訪問。

2、類的保護成員可以被該類及其派生類訪問，不可以被該類的對象訪問。

3、類的私有成員可以被該類訪問，不可以被派生類及其該類的對象訪問。

Ⅱ java中類修飾符有哪些

1.class不加修飾符的時候 即直接聲明 class A{ }

在這種情況下，class前面沒有加任何的訪問修飾符，通常稱為「默認訪問模式」，在該模式下，這個類只能被同一個包中的類訪問或引用，這一訪問特性又稱包訪問性。

2.類修飾符：

(1)public（訪問控制符），將一個類聲明為公共類，他可以被任何對象訪問，一個程序的主類必須是公共類。

(2)java累擴展閱讀： 網路-java關鍵字

Ⅲ Java類的定義

package java.lancs ;

/**
* Graphics objects for practical classes (Java 1.1 version)
* @author Roger Garside/Richard Cardoe
* @version Last Rewritten: 24/Sept/97
*/

import java.awt.* ;
import java.awt.event.* ;

/*
* class to hold details about the shape to draw
*/
class BasicShape
{
// name of the shape - RECTANGLE, OVAL, etc.
int shape ;
// dimensions of the shape
int x, y, w, h ;
// colour of the shape
Color colour ;

// constructor to initialise the variables to default values
public BasicShape()
{
shape = -1 ;
x = -1 ;
y = -1 ;
w = -1 ;
h = -1 ;
colour = Color.green ;
} // end of constructor method

// constructor to initialise the variables to specifier values
public BasicShape(int sh, int x1, int y1, int w1, int h1, Color col)
{
shape = sh ;
x = x1 ;
y = y1 ;
w = w1 ;
h = h1 ;
colour = col ;
} // end of constructor method
} // end of class BasicShape

/*
* a canvas to draw on
*/
class BasicCanvas extends Canvas
{
BasicGraphics parent ;

// constructor method
public BasicCanvas(BasicGraphics p)
{
parent = p ;
} // end of constructor method

// called when class is initialised to put window on the screen
// or when window needs to be redrawn
public void paint(Graphics g)
{
Dimension d = getSize() ;
int cx = d.width / 2,
cy = d.height /2 ;
g.setColor(Color.black) ;
g.drawRect(1, 1, d.width - 3, d.height - 3) ;
int yy = 25 ;
while (yy < d.height)
{
if (yy % 100 == 0)
{
g.drawLine(1, yy, 11, yy) ;
g.drawLine(d.width - 13, yy, d.width - 3, yy) ;
}
else
{
g.drawLine(1, yy, 6, yy) ;
g.drawLine(d.width - 8, yy, d.width - 3, yy) ;
}
yy += 25 ;
}
int xx = 25 ;
while (xx < d.width)
{
if (xx % 100 == 0)
{
g.drawLine(xx, 1, xx, 11) ;
g.drawLine(xx, d.height - 13, xx, d.height - 3) ;
}
else
{
g.drawLine(xx, 1, xx, 6) ;
g.drawLine(xx, d.height - 8, xx, d.height - 3) ;
}
xx += 25 ;
}

for (int i = 0 ; i < parent.noOfShapes ; i++)
{
g.setColor(parent.shapeList[i].colour) ;

if (parent.shapeList[i].shape == BasicGraphics.RECTANGLE)
{
g.drawRect(parent.shapeList[i].x, parent.shapeList[i].y,
parent.shapeList[i].w, parent.shapeList[i].h) ;
}
else if (parent.shapeList[i].shape == BasicGraphics.FILLED_RECTANGLE)
{
g.fillRect(parent.shapeList[i].x, parent.shapeList[i].y,
parent.shapeList[i].w, parent.shapeList[i].h) ;
}
else if (parent.shapeList[i].shape == BasicGraphics.OVAL)
{
g.drawOval(parent.shapeList[i].x, parent.shapeList[i].y,
parent.shapeList[i].w, parent.shapeList[i].h) ;
}
else if (parent.shapeList[i].shape == BasicGraphics.FILLED_OVAL)
{
g.fillOval(parent.shapeList[i].x, parent.shapeList[i].y,
parent.shapeList[i].w, parent.shapeList[i].h) ;
}
else if ((parent.shapeList[i].shape == BasicGraphics.TRIANGLE) ||
(parent.shapeList[i].shape == BasicGraphics.FILLED_TRIANGLE))
{
int x1 = parent.shapeList[i].x ;
int y1 = parent.shapeList[i].y ;
int w1 = parent.shapeList[i].w ;
int h1 = parent.shapeList[i].h ;

Polygon p = new Polygon() ;
p.addPoint(x1, y1 + h1) ;
p.addPoint(x1 + w1, y1 + h1) ;
p.addPoint(x1 + (w1 / 2), y1) ;
p.addPoint(x1, y1 + h1) ;

if (parent.shapeList[i].shape == BasicGraphics.TRIANGLE)
g.drawPolygon(p) ;
else
g.fillPolygon(p) ;
}
}
} // end of method paint

} // end of class BasicCanvas

/*
* class to draw simple shapes in a window
*/
public class BasicGraphics extends Frame implements ActionListener
{
// maximum width of window
private static final int MAX_WIDTH = 600 ;

// maximum height of window
private static final int MAX_HEIGHT = 400 ;

/**
* definition of a rectangle shape
*/
public static final int RECTANGLE = 1 ;

/**
* definition of an oval shape
*/
public static final int OVAL = 2 ;

/**
* definition of a triangle shape
*/
public static final int TRIANGLE = 3 ;

/**
* definition of a filled-in rectangle
*/
public static final int FILLED_RECTANGLE = 4 ;

/**
* definition of a filled-in oval
*/
public static final int FILLED_OVAL = 5 ;

/**
* definition of a filled-in triangle
*/
public static final int FILLED_TRIANGLE = 6 ;

BasicShape[] shapeList = new BasicShape[50];

int noOfShapes = 0;

private BasicShape newShape = new BasicShape();

private Button quit ;

/**
* constructor to lay out the window
*/
public BasicGraphics()
{
setTitle("BasicGraphics Window") ;
setSize(MAX_WIDTH, MAX_HEIGHT + 50) ;

BasicCanvas c = new BasicCanvas(this) ;
add("Center", c) ;

Panel p = new Panel() ;
p.setLayout(new FlowLayout()) ;
quit = new Button("Quit") ;
p.add(quit) ;
quit.addActionListener(this) ;
add("South", p) ;
} // end of constructor method

/**
* handles button depression events, etc.
*/
public void actionPerformed(ActionEvent event)
{
dispose() ;
System.exit(0) ;
} // end of method actionPerformed

/**
* set the type of shape that you want to draw
* @param shape e.g. BasicGraphics.RECTANGLE
*/
public void setShape(int shape)
{
if ((shape != RECTANGLE) && (shape != FILLED_RECTANGLE) &&
(shape != OVAL) && (shape != FILLED_OVAL) &&
(shape != TRIANGLE) && (shape != FILLED_TRIANGLE))
{
System.err.println("This is not a valid shape");
System.exit(1);
}
newShape.shape = shape ;
} // end of method setShape

/**
* set the dimensions of the shape that you want to draw
* @param x x-coordinate of the top left hand corner of the bounding
* rectangle
* @param y y-coordinate of the top left hand corner of the bounding
* rectangle
* @param w width of the bounding rectangle
* @param h height of the bounding rectangle
*/
public void setDimensions(int x, int y, int w, int h)
{
if (newShape.shape == -1)
{
System.err.println("You need to set the shape first");
System.exit(1);
}
if ((x < 5) || (y < 5) || (w < 5) || (h < 5) ||
(x + w > MAX_WIDTH - 5) || (y + h > MAX_HEIGHT - 5))
{
System.err.println("Invalid dimensions supplied") ;
System.exit(1);
}
newShape.x = x ;
newShape.y = y ;
newShape.w = w ;
newShape.h = h ;
} // end of method setDimensions

/**
* set the colour of the shape that you want to draw
* @param colour the Color type (Color.red, Color.blue, etc.)
*/
public void setColour(Color colour)
{
if (newShape.x == -1)
{
System.err.println("You need to set the dimensions first");
System.exit(1);
}
newShape.colour = colour ;
shapeList[noOfShapes] = new BasicShape(newShape.shape,
newShape.x, newShape.y,
newShape.w, newShape.h,
newShape.colour) ;
noOfShapes++ ;
newShape = new BasicShape() ;
} // end of method setColour

/**
* draws the window on the screen with the specified shapes
*/
public void draw()
{
setVisible(true) ;
} // end of method draw

} // end of class BasicGraphics

Ⅳ 什麼是java類

java類就是具備某些共同特徵的實體的集合，它是一種抽象的數據類型，它是對所具有相同特徵實體的抽象。在面向對象的程序設計語言中，類是對一類「事物」的屬性與行為的抽象。

Java中的類是用戶定義的數據類型，藍圖，分類，它描述其類型的對象支持的行為/狀態。

舉一個例子說明下類，比如Person(人)就是一個類，那麼具體的某個人「張三」就是「人類」這個類的對象，而「姓名、身高、體重」等信息就是對象的屬性，人的動作比如「吃飯、穿衣」等就是對象的方法。

總之類就是有相同特徵的悉手事物的集合，而對象就是類的一個具體實例。同時類有多態和繼承，例如「人類」可以分尺岩為「男人、女人」，「老人、小孩」那麼「男人、女人」就是「人類」睜困嫌的子類等等。

Ⅳ java中有哪些類庫

java類庫：

1. java.lang包：

java最常用的包，程序不需要注入，就可以使用該包中的類，利用包中的類可以設計最基本的Java程序；

2.java.awt包 ：

提供了圖形界面的創建方法，包括按鈕、文本框、返螞列表框、容器、字體、顏色和圖形等元素的建立和設置；

3.javax.swing包：

Java編寫的圖形界面提供創建類，利用javax.swing包的類建立的界面元素可調整為各種操作系統的界面風格，支持扒洞各種操作平台的界面的開發，swing包還提供了樹形控制項、表格控制項的類等；

4.java.io包：

提供數據流方式的系統輸入輸出控制、文件和對象的讀寫串列化處理；

5..java.util包：

提供時間日期、隨機數以及列表、 *** 、哈希表和堆棧春世枯等創建復雜數據結構的類；

6.java包：

提供網路開發的支持；

7.java.apple包：

包含Applet類，提供多媒體、網路功能。

Ⅵ 請問java中的類是什麼意思

Java創建一個類的關鍵字為class，基本語法格式為public class ClassName{};在開發中，通常類的名字首字母大寫。類中包含了類的特定屬性，比如我們創建一個動物類，動物有自己的屬性名字，年齡等屬性特點，我們創建好動物這個類之後，當需要一個動物的時候，就去創建一個動物的對象，之後使用這個具體的對象進行操作就可以。創建對象的關鍵字是new，基本語法為 ClassName objectName = new ClassName();
在Java中類的構造函數包含有參構造函數和無參構造函數，默認如果不在類中寫構造函數，默認有一個無參的構造函數，當創建一個對象的時候，默認使用的就是這個構造函數。
如果需要在創建對象的時候就將對象的屬性值設置好，就需要一個有參構造函數，在創建對象的時候，將參數傳入即可。如果創建一個有參的構造函數，那麼默認的無參構造函數將會被覆蓋，如果還需要一個無參構造函數，則需要手動重寫一個無參構造函數。
Java類可以被繼承，子類會繼承父類的一些屬性值，但是子類也可以有自己的一些特定屬性，小狗(子類)屬於動物(父類)，有動物這個種類的所有屬性，但是小狗也有屬於自己的特性。在開發中我們會將具有某些基本屬性的歸為一類，如果另一個類也有這些屬性，而且它還有屬於自己的特性，可以將子類繼承於父類，這樣子類就包含了父類所有的屬性。
Java類的繼承關鍵字是extends，基本語法為： public class ChiledClass extends ParentClass{};
在子類中，有時候雖然繼承了父類的屬性值，但是有時候，我們需要子類中的該屬性值有自己的特點，這時候，我們可以重寫父類的屬性方法，將該屬性設置為我們需要的值，這樣雖然子類繼承於父類，但是也有自己的獨特性。
在開發中，我們通常會將類的屬性設置為私有的，這樣外部就不會隨意訪問到這個屬性。但是為了讓外部能夠訪問該屬性值，我們通常使用 set和get方法去設置和獲取該屬性值，這樣如果開發中不想讓別人隨意修改該屬性，可以將set方法去掉，只留下get方法，這樣這個屬性就只可以訪問而不可以修改，很好的保護的這個屬性值，不讓別人去隨意修改。

Ⅶ java中有哪些類

如下：

String 字元串類

System 可得到系統信息

StringBuilder 字元串工具類

Thread 線程類

Math 與數學有關的工具類

ArrayList 底層用數組實現的集合

LinkedList 底層用鏈表實現的集合

HashMap 介面Map的一個實現類

HashSet 介面Set的一個實現類

Scanner 簡單文本掃描器

Calendar 日期類

Date 日期類

File 目錄或文件操作類

FileInputStream 輸入流

FileOutputStream 輸出流

BufferedInputStream 具有緩沖的輸入流

BufferedOutputStream 具有緩沖的輸出流

BufferedReader 從字元輸入流中讀取文本，緩沖各個字元

Java是一門面向對象編程語言，不僅吸收了C++語言的各種優點，還摒棄了C++里難以理解的多繼承、指針等概念，因此Java語言具有功能強大和簡單易用兩個特徵。Java語言作為靜態面向對象編程語言的代表，極好地實現了面向對象理論，允許程序員以優雅的思維方式進行復雜的編程。

Java具有簡單性、面向對象、分布式、健壯性、安全性、平台獨立與可移植性、多線程、動態性等特點。Java可以編寫桌面應用程序、Web應用程序、分布式系統和嵌入式系統應用程序等。

Ⅷ java中什麼是類

.JAVA中的類是具備某些共同特徵凱襲的實體的集合，它是一種抽象的概念；2.用程序設計的語言來說，類是一種抽象的數據類型，它是對所具有盯好兄相同特徵實體的抽象；3.所謂對象就是真實世界中的實體，對象與實體是一一對應的，也就是說現實世界中每一個實體都是一個對象，對象是一種具體的概念。4.類是對象的集合，對象是類的實例;對象是通過襪塌new
className產生的，用來調用類的方法;類的構造方法
。

Ⅸ 怎麼用"java"寫一個類

class B{\x0d\x0a private int a;//聲明變數\x0d\x0a public B()//構造函數\x0d\x0a{\x0d\x0a}\x0d\x0apublic void setA(int a)//設置a的值\x0d\x0a{\x0d\x0a this.a=a;\x0d\x0a\x0d\x0a}\x0d\x0apublic int getA()//獲取a的值\x0d\x0a{\x0d\x0areturn a;\x0d\x0a}\x0d\x0apublic public static void main(String[] args)//必須要的主函數\x0d\x0a{\x0d\x0aB b=new B();//建立一個B的對象b\x0d\x0ab.setA(3);//調用b對象里的方法setA（）；\x0d\x0aSystem.out.println(b.getA);//輸出a\x0d\x0a\x0d\x0a}\x0d\x0a\x0d\x0a}

Ⅹ Java中常用的類有哪些

一. System:

1.首先是System類，因為從一開始從接觸java起，我們就無時無刻都在接觸它，經常用它來向屏幕，向控制台列印輸出一些信息，System.out.println(「hello world」);這個只是在控制台輸出一條信息「hello world」，今天我們學到這里，才知道out只是System類中的一個欄位，也就是一個成員變數，而且還是靜態的，是一個對象的引用，即PrintStream，是標準的輸出流，向標準的輸出設備輸出信息的，所以我們這里才調用了對象out的println()這個方法。所以類似與out欄位的還有其他兩個，如in是InputStream類的一個對象，那麼in則是一個標準的輸入對象，他可以讀取或則也可以說從鍵盤或則其他輸入設備接收或者讀入一個信息，那麼err也是PrintStream類的一個對象，則是標準的錯誤輸出流，那其實這些所謂的標準的輸入輸出，他們功能實現底層是靠C語言和設備直接溝通的，java只是依賴C語言完成了這些功能。

2.老師說學習System這個類並不是說要去做太多的深入了解，而是希望我們能掌握一些查閱API，掌握這個類中常用的幾個方法，在以後的開發中能夠寫出一些需要的小東西。

3.Java中System這個類中的屬性和方法都是靜態的，可以通過類名可以直接調用，而且它位於java默認的包中java.lang包中，一般情況下我們要使用它的方法和屬性，是不需要做導入包的動作的，然後我們還發先這個類沒有構造方法，所以這就說明我們不能創建一個System類的對象，只能通過類名來直接調用它的屬性和方法了，注意，它還是一個final類型的修飾的類。那麼我們來看看還有什麼那些方法比較重要呢？