java自定

A. java自定義類及使用

1. class定義類 public class Person{}

2. 使用類，需要創建類的對象 Person p = new Person()

3. 在Java中，類文件是以.java為後綴的代碼文件，在每個類文件中最多隻允許出現一個public類，當有public類的時候，類文件的名稱必須和public類的名稱相同，若不存在public，則類文件的名稱可以為任意的名稱（當然以數字開頭的名稱是不允許的）。

4. 在類內部，對於成員變數，如果在定義的時候沒有進行顯示的賦值初始化，則Java會保證類的每個成員變數都得到恰當的初始化：

5. 對於 char、short、byte、int、long、float、double等基本數據類型的變數來說會默認初始化為0（boolean變數默認會被初始化為false）；

6. 對於引用類型的變數，會默認初始化為null。

7. 如果沒有顯示地定義構造器，則編譯器會自動創建一個無參構造器，但是要記住一點，如果顯示地定義了構造器，編譯器就不會自動添加構造器。

B. java 自定義類型

1.Java中定義類的方法
class 類名
用Java語法定義人類：
public class Person
{
}

2。對象的定義方法

1，對象聲明：類名 對象名；

2，對象創建 對象名 = new 類名（）； 作用：分配內存空間。
合寫為：類名 對象名 = new 類名();

3.例子：創建一個空調，並調用製冷。

//設計一個空調
package practice;

public class Kongtiao {
//空調屬性
String name;
String pinpai;
String pishu;
int tempeture;

//定義製冷行為
void cool()
{
tempeture--;
}

//定義加熱行為
void hot()
{
tempeture+=7;
}
//主函數
public static void main(String[] args){
Kongtiao kt = new Kongtiao();
kt.name = "美的";
kt.pishu = "2匹";
kt.tempeture = 20;
kt.pinpai = "志高";
/**
kt.cool();
System.out.println("空調的溫度是"+kt.tempeture);
*/

kt.hot();
System.out.println("空調的溫度是"+kt.tempeture);

}
}

C. JAVA如何自定義一個方法

public class my
{
my(){};//構造函數
public int add()//這個就是自定義方法了，這是一個公共，返回整型的方法
{
return 5+5;
}
}

你也可以這樣定義：
public float add()//返回浮點類型
private float add()//定義該方法為類的私有方法，只能由類內定義的變數或方法訪問
還有諸如static關鍵字等等，這樣一時也說不明白，還是建議你去找一本java的教程看一下吧，<<Thinking in JAVA>>應該可以讓你成長，找一下候捷翻譯的第二版，<<JAVA編程思想（第二版）>>，電子工業出版社出版

D. 關於java的自定義方法。。。。

暈，這是Javse的基礎玩意，建議你還是再去好好看看去，基礎搞不懂的話，後續程序很難開展的。
school你定義的是私有（private），除了Student類外可以訪問調用，其他類都不可以，所以你定義了一個setSchool方法，通過這個方法你可以給school重新賦值。賦值後，其他類或者對象就可以通過getSchool方法獲得你賦值後的School值。
還有public String getschool 是一個你自己定義的方法，不是成員變數。其中String的意思是該方法返回一個字元串類型的。 getSchool 是你定義的方法名字。
String school 這個才是成員變數。
至於內存分析，你得先搞明白上面的東西，你才能知道內存棧與堆等。不過上面的程序沒有new出新的對象，因此不涉及到堆，只是在內存棧中進行的！！
哥們， 我是0基礎的剛接觸Java有不到半個月，深感基礎的重要性啊！！好好努力吧···共勉吧

E. 如何使用java自定義類

小兄弟，java 中每個類都是自定義的；

每個類都可以有屬性和方法；

比如：
class student{
Sting name;
int age;
long id;

public void 做活動{

}
}

這時候，你使用這個類，就只需要實例化它；

就像下面：

student a = new student();

如果對回答滿意，請點【採納答案】，如果還有問題，請點【追問】

希望我的回答對您有所幫助，希望能採納。

F. 在java中建一個自定義類的好處是什麼

自定義一個類的目的就是相當於整理分類；
1 描述這個類的屬性和作用 ： 比如你自定義一個Person類，就是人類，你可以通過屬性（比如兩隻眼睛 兩只耳朵 ）和行為（行為簡單的理解就是能幹什麼 比如人能跑 能跳 能吃飯）把人這個類描述清楚。
2 可以供其他開發人員調用， 意思就是比如你已經定要好了一個Pserson了，現在其他的開發人員用到了這個人類的相關操作，可以直接調用，他就不用再去寫一個人類了，減少代碼的重復性，提高工作效率。

G. Java中如何調用函數和自定義函數

調用函數

System.out.println("hello world");

println即為函數，out為是輸出對象，System為java系統類。

Java源程序（.java文件）——>java位元組碼文件（.class文件）——>由解釋執行器（java.exe）將位元組碼文件載入到java虛擬機（jvm）——>位元組碼文件（.class）就會在java虛擬機中執行。

Java的基本包
java.lang其中包含有：
介面：Comparable、Cloneable、Runable等
類：八個基本數據類型封裝類、Math、Runtime、Object、String、StringBuffer、Thread、Exception等

H. java里怎麼自定義一個日期！

在舊版本的jdk中，Java的日期/時間類的定義並不一致，在java.util和java.sql的包中都有日期類，此外用於格式化和解析的類在java.text.SimpleDateFormat包中定義。

java.util.Date是在除了SQL語句的情況下面使用的。
java.sql.Date是針對SQL語句使用的，它只包含日期而沒有時間部分

它們都有getTime方法返回毫秒數，自然就可以直接構建。java.util.Date 是 java.sql.Date 的父類，前者是常用的表示時間的類，我們通常格式化或者得到當前時間都是用他，後者之後在讀寫資料庫的時候用他，因為PreparedStament的setDate()的第2參數和ResultSet的getDate()方法的第2個參數都是java.sql.Date。

java.sql.Date轉為java.util.Date
java.sql.Date date=new java.sql.Date();
java.util.Date d=new java.util.Date (date.getTime());

java.util.Date轉為java.sql.Date
java.util.Date utilDate=new Date();
java.sql.Date sqlDate=new java.sql.Date(utilDate.getTime());
java.util.Date utilDate=new Date();
java.sql.Date sqlDate=new java.sql.Date(utilDate.getTime());
java.sql.Time sTime=new java.sql.Time(utilDate.getTime());
java.sql.Timestamp stp=new java.sql.Timestamp(utilDate.getTime());

這里所有時間日期都可以被SimpleDateFormat格式化format()
SimpleDateFormat f=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
f.format(stp);
f.format(sTime);
f.format(sqlDate);
f.format(utilDate)
java.sql.Date sqlDate=java.sql.Date.valueOf(" 2005-12-12");
utilDate=new java.util.Date(sqlDate.getTime());

另類取得年月日的方法：
import java.text.SimpleDateFormat;
import java.util.*;
java.util.Date date = new java.util.Date();
//如果希望得到YYYYMMDD的格式SimpleDateFormat
sy1=new SimpleDateFormat("yyyyMMDD");
String dateFormat=sy1.format(date);
//如果希望分開得到年，月，日SimpleDateFormat
sy=new SimpleDateFormat("yyyy");
SimpleDateFormat sm=new SimpleDateFormat("MM");
SimpleDateFormat sd=new SimpleDateFormat("dd");
String syear=sy.format(date);
String smon=sm.format(date);
String sday=sd.format(date);

注意啦！！！在JAVA 8中有了日期的新的表示方式。在java.time包中。

Java 8日期/時間（ Date/Time）API是開發人員最受追捧的變化之一，Java從一開始就沒有對日期時間處理的一致性方法，因此日期/時間API也是除Java核心API以外另一項倍受歡迎的內容。

為什麼我們需要新的Java日期/時間API？

在開始研究Java 8日期/時間API之前，讓我們先來看一下為什麼我們需要這樣一個新的API。在Java中，現有的與日期和時間相關的類存在諸多問題，其中有：

1. Java的日期/時間類的定義並不一致，在java.util和java.sql的包中都有日期類，此外用於格式化和解析的類在java.text包中定義。

2. java.util.Date同時包含日期和時間，而java.sql.Date僅包含日期，將其納入java.sql包並不合理。另外這兩個類都有相同的名字，這本身就是一個非常糟糕的設計。

3. 對於時間、時間戳、格式化以及解析，並沒有一些明確定義的類。對於格式化和解析的需求，我們有java.text.DateFormat抽象類，但通常情況下，SimpleDateFormat類被用於此類需求。

4. 所有的日期類都是可變的，因此他們都不是線程安全的，這是Java日期類最大的問題之一。

5. 日期類並不提供國際化，沒有時區支持，因此Java引入了java.util.Calendar java.util.TimeZone類，但他們同樣存在上述所有的問題。

在現有的日期和日歷類中定義的方法還存在一些其他的問題，但以上問題已經很清晰地表明：Java需要一個健壯的日期/時間類。這也是為什麼Joda Time在Java日期/時間需求中扮演了高質量替換的重要角色。

Java 8日期/時間API是JSR-310的實現，它的實現目標是克服舊的日期時間實現中所有的缺陷，新的日期/時間API的一些設計原則是：

1. 不變性：新的日期/時間API中，所有的類都是不可變的，這對多線程環境有好處。

2. 關注點分離：新的API將人可讀的日期時間和機器時間（unix timestamp）明確分離，它為日期（Date）、時間（Time）、日期時間（DateTime）、時間戳（unix timestamp）以及時區定義了不同的類。

3. 清晰：在所有的類中，方法都被明確定義用以完成相同的行為。舉個例子，要拿到當前實例我們可以使用now()方法，在所有的類中都定義了format()和parse()方法，而不是像以前那樣專門有一個獨立的類。為了更好的處理問題，所有的類都使用了工廠模式和策略模式，一旦你使用了其中某個類的方法，與其他類協同工作並不困難。

4. 實用操作：所有新的日期/時間API類都實現了一系列方法用以完成通用的任務，如：加、減、格式化、解析、從日期/時間中提取單獨部分，等等。

5. 可擴展性：新的日期/時間API是工作在ISO-8601日歷系統上的，但我們也可以將其應用在非IOS的日歷上。

Java日期/時間API包含以下相應的包。

1. java.time包：這是新的Java日期/時間API的基礎包，所有的主要基礎類都是這個包的一部分，如：LocalDate, LocalTime, LocalDateTime, Instant, Period, Duration等等。所有這些類都是不可變的和線程安全的，在絕大多數情況下，這些類能夠有效地處理一些公共的需求。

2. java.time.chrono包：這個包為非ISO的日歷系統定義了一些泛化的API，我們可以擴展AbstractChronology類來創建自己的日歷系統。

3. java.time.format包：這個包包含能夠格式化和解析日期時間對象的類，在絕大多數情況下，我們不應該直接使用它們，因為java.time包中相應的類已經提供了格式化和解析的方法。

4. java.time.temporal包：這個包包含一些時態對象，我們可以用其找出關於日期/時間對象的某個特定日期或時間，比如說，可以找到某月的第一天或最後一天。你可以非常容易地認出這些方法，因為它們都具有「withXXX」的格式。

5. java.time.zone包：這個包包含支持不同時區以及相關規則的類。

新舊API的對比圖：

publicclassTimeIntroction{
publicstaticvoidtestClock()throwsInterruptedException{
//時鍾提供給我們用於訪問某個特定時區的瞬時時間、日期和時間的。
Clockc1=Clock.systemUTC();//系統默認UTC時鍾（當前瞬時時間System.currentTimeMillis()）
System.out.println(c1.millis());//每次調用將返回當前瞬時時間（UTC）
Clockc2=Clock.systemDefaultZone();//系統默認時區時鍾（當前瞬時時間）
Clockc31=Clock.system(ZoneId.of("Europe/Paris"));//巴黎時區
System.out.println(c31.millis());//每次調用將返回當前瞬時時間（UTC）
Clockc32=Clock.system(ZoneId.of("Asia/Shanghai"));//上海時區
System.out.println(c32.millis());//每次調用將返回當前瞬時時間（UTC）
Clockc4=Clock.fixed(Instant.now(),ZoneId.of("Asia/Shanghai"));//固定上海時區時鍾
System.out.println(c4.millis());
Thread.sleep(1000);
System.out.println(c4.millis());//不變即時鍾時鍾在那一個點不動
Clockc5=Clock.offset(c1,Duration.ofSeconds(2));//相對於系統默認時鍾兩秒的時鍾
System.out.println(c1.millis());
System.out.println(c5.millis());
}
publicstaticvoidtestInstant(){
//瞬時時間相當於以前的System.currentTimeMillis()
Instantinstant1=Instant.now();
System.out.println(instant1.getEpochSecond());//精確到秒得到相對於1970-01-0100:00:00UTC的一個時間
System.out.println(instant1.toEpochMilli());//精確到毫秒
Clockclock1=Clock.systemUTC();//獲取系統UTC默認時鍾
Instantinstant2=Instant.now(clock1);//得到時鍾的瞬時時間
System.out.println(instant2.toEpochMilli());
Clockclock2=Clock.fixed(instant1,ZoneId.systemDefault());//固定瞬時時間時鍾
Instantinstant3=Instant.now(clock2);//得到時鍾的瞬時時間
System.out.println(instant3.toEpochMilli());//equalsinstant1
}
(){
//使用默認時區時鍾瞬時時間創建Clock.systemDefaultZone()-->即相對於ZoneId.systemDefault()默認時區
LocalDateTimenow=LocalDateTime.now();
System.out.println(now);
//自定義時區
LocalDateTimenow2=LocalDateTime.now(ZoneId.of("Europe/Paris"));
System.out.println(now2);//會以相應的時區顯示日期
//自定義時鍾
Clockclock=Clock.system(ZoneId.of("Asia/Dhaka"));
LocalDateTimenow3=LocalDateTime.now(clock);
System.out.println(now3);//會以相應的時區顯示日期
//不需要寫什麼相對時間如java.util.Date年是相對於1900月是從0開始
//2013-12-3123:59
LocalDateTimed1=LocalDateTime.of(2013,12,31,23,59);
//年月日時分秒納秒
LocalDateTimed2=LocalDateTime.of(2013,12,31,23,59,59,11);
//使用瞬時時間+時區
Instantinstant=Instant.now();
LocalDateTimed3=LocalDateTime.ofInstant(Instant.now(),ZoneId.systemDefault());
System.out.println(d3);
//解析String--->LocalDateTime
LocalDateTimed4=LocalDateTime.parse("2013-12-31T23:59");
System.out.println(d4);
LocalDateTimed5=LocalDateTime.parse("2013-12-31T23:59:59.999");//999毫秒等價於999000000納秒
System.out.println(d5);
//使用DateTimeFormatterAPI解析和格式化
DateTimeFormatterformatter=DateTimeFormatter.ofPattern("yyyy/MM/ddHH:mm:ss");
LocalDateTimed6=LocalDateTime.parse("2013/12/3123:59:59",formatter);
System.out.println(formatter.format(d6));
//時間獲取
System.out.println(d6.getYear());
System.out.println(d6.getMonth());
System.out.println(d6.getDayOfYear());
System.out.println(d6.getDayOfMonth());
System.out.println(d6.getDayOfWeek());
System.out.println(d6.getHour());
System.out.println(d6.getMinute());
System.out.println(d6.getSecond());
System.out.println(d6.getNano());
//時間增減
LocalDateTimed7=d6.minusDays(1);
LocalDateTimed8=d7.plus(1,IsoFields.QUARTER_YEARS);
//LocalDate即年月日無時分秒
//LocalTime即時分秒無年月日
//API和LocalDateTime類似就不演示了
}
(){
//即帶有時區的date-time存儲納秒、時區和時差（避免與本地date-time歧義）。
//API和LocalDateTime類似，只是多了時差(如2013-12-20T10:35:50.711+08:00[Asia/Shanghai])
ZonedDateTimenow=ZonedDateTime.now();
System.out.println(now);
ZonedDateTimenow2=ZonedDateTime.now(ZoneId.of("Europe/Paris"));
System.out.println(now2);
//其他的用法也是類似的就不介紹了
ZonedDateTimez1=ZonedDateTime.parse("2013-12-31T23:59:59Z[Europe/Paris]");
System.out.println(z1);
}
publicstaticvoidtestDuration(){
//表示兩個瞬時時間的時間段
Durationd1=Duration.between(Instant.ofEpochMilli(System.currentTimeMillis()-12323123),Instant.now());
//得到相應的時差
System.out.println(d1.toDays());
System.out.println(d1.toHours());
System.out.println(d1.toMinutes());
System.out.println(d1.toMillis());
System.out.println(d1.toNanos());
//1天時差類似的還有如ofHours()
Durationd2=Duration.ofDays(1);
System.out.println(d2.toDays());
}
(){
//提供對java.util.Calendar的替換，提供對年歷系統的支持
Chronologyc=HijrahChronology.INSTANCE;
ChronoLocalDateTimed=c.localDateTime(LocalDateTime.now());
System.out.println(d);
}
/**
*新舊日期轉換
*/
(){
Instantinstant=newDate().toInstant();
Datedate=Date.from(instant);
System.out.println(instant);
System.out.println(date);
}
publicstaticvoidmain(String[]args)throwsInterruptedException{
testClock();
testInstant();
testLocalDateTime();
testZonedDateTime();
testDuration();
testChronology();
testNewOldDateConversion();
}
}

I. java注釋的自定義

它類似於新創建一個介面類文件，但為了區分，我們需要將它聲明為@interface,如下例：
Java代碼
packagecom.iwtxokhtd.annotation;
public@interfaceNewAnnotation {
}
使用自定義的註解類型
Java代碼
packagecom.iwtxokhtd.annotation;
publicclassAnnotationTest {
@NewAnnotation
publicstaticvoidmain(String[] args) {
}
}
為自定義註解添加變數
Java代碼
packagecom.iwtxokhtd.annotation;
public@interfaceAnnotation {
String value();
}
Java代碼
publicclassAnnotationTest {
@NewAnnotation(main method)
publicstaticvoidmain(String[] args) {
saying();
}
@NewAnnotation(value = say method)
publicstaticvoidsaying() {
}
}
定義一個枚舉類型，然後將參數設置為該枚舉類型，並賦予默認值
public@interfaceGreeting {
publicenum FontColor {
BLUE,RED,GREEN
};
String name();
FontColor fontColor()defaultFontColor.RED;
}
這里有兩種選擇，其實變數也就是在賦予默認值的參數上，我們可以選擇使用該默認值，也可以重新設置一個值來替換默認值
Java代碼
publicclassAnnotationTest {
@NewAnnotation(main method)
publicstaticvoidmain(String[] args) {
saying();
sayHelloWithDefaultFontColor();
sayHelloWithRedFontColor();
}
@NewAnnotation(say method)
publicstaticvoidsaying() {
}
// 此時的fontColor為默認的RED
@Greeting(name = defaultfontcolor)
() {
}
@Greeting(name = notdefault, fontColor = Greeting.FontColor.BLUE)
() {
} 1.1. 限制註解的使用范圍
用@Target指定ElementType屬性
Java代碼(jdk)
packagejava.lang.annotation;
public enum ElementType {
TYPE,
// 用於類，介面，枚舉但不能是註解
FIELD,
// 欄位上，包括枚舉值
METHOD,
// 方法，不包括構造方法
PARAMETER,
// 方法的參數
CONSTRUCTOR,
//構造方法
LOCAL_VARIABLE,
// 本地變數或catch語句
ANNOTATION_TYPE,
// 註解類型(無數據)
PACKAGE
// Java包
}
1.2. 註解保持性策略
Java代碼
//限制註解使用范圍
@Target({ElementType.METHOD,ElementType.CONSTRUCTOR})
public @interface Greeting {
//使用枚舉類型
public enum FontColor{
BLUE,RED,GREEN
};
String name();
FontColor fontColor() defaultFontColor.RED;
}
在Java編譯器編譯時，它會識別在源代碼里添加的註解是否還會保留，這就是RetentionPolicy。下面是Java定義的RetentionPolicy枚舉：
編譯器的處理有三種策略：
將註解保留在編譯後的類文件中，並在第一次載入類時讀取它
將註解保留在編譯後的類文件中，但是在運行時忽略它
按照規定使用註解，但是並不將它保留到編譯後的類文件中
Java代碼
packagejava.lang.annotation;
public enum RetentionPolicy{
SOURCE,
// 此類型會被編譯器丟棄
CLASS,
// 此類型註解會保留在class文件中，但JVM會忽略它
RUNTIME
// 此類型註解會保留在class文件中，JVM會讀取它
}
Java代碼
//讓保持性策略為運行時態，即將註解編碼到class文件中，讓虛擬機讀取
@Retention(RetentionPolicy.RUNTIME)
public @interface Greeting {
//使用枚舉類型
public enum FontColor{
BLUE,RED,GREEN
};
String name();
FontColor fontColor() defaultFontColor.RED;
}
1.3. 文檔化功能
Java提供的Documented元註解跟Javadoc的作用是差不多的，其實它存在的好處是開發人員可以定製Javadoc不支持的文檔屬性，並在開發中應用。它的使用跟前兩個也是一樣的，簡單代碼示例如下：
Java代碼
//讓它定製文檔化功能
//使用此註解時必須設置RetentionPolicy為RUNTIME
@Documented
public @interface Greeting {
//使用枚舉類型
public enum FontColor{
BLUE,RED,GREEN
};
String name();
FontColor fontColor() defaultFontColor.RED;
}
1.4. 標注繼承
Java代碼
//讓它允許繼承，可作用到子類
@Inherited
public @interface Greeting {
//使用枚舉類型
public enum FontColor{
BLUE,RED,GREEN
};
String name();
FontColor fontColor() defaultFontColor.RED;
}
2. 讀取註解信息
屬於重點，在系統中用到註解許可權時非常有用，可以精確控制許可權的粒度
注意：要想使用反射去讀取註解，必須將Retention的值選為Runtime
Java代碼
packagecom.iwtxokhtd.annotation;
importjava.lang.annotation.Annotation;
importjava.lang.reflect.Method;
//讀取註解信息
{
publicstaticvoidmain(String[] args)throws Exception {
// 測試AnnotationTest類，得到此類的類對象
Class c = Class.forName(com.iwtxokhtd.annotation.AnnotationTest);
// 獲取該類所有聲明的方法
Method[] methods =c.getDeclaredMethods();
// 聲明註解集合
Annotation[] annotations;
// 遍歷所有的方法得到各方法上面的註解信息
for(Method method : methods) {
// 獲取每個方法上面所聲明的所有註解信息
annotations =method.getDeclaredAnnotations();
// 再遍歷所有的註解，列印其基本信息
System.out.println(method.getName());
for(Annotation an :annotations) {
System.out.println(方法名為： + method.getName()+ 其上面的註解為：
+an.annotationType().getSimpleName());
Method[] meths =an.annotationType().getDeclaredMethods();
// 遍歷每個註解的所有變數
for(Method meth :meths) {
System.out.println(註解的變數名為： + meth.getName 注釋有三種：// /* */ /** */ 前兩種編譯器直接跳過，從來不閱讀，第三種編譯器是可以看懂的，當你使用javadoc這樣的命令時會用到，用來生成API時用的。
註解：這東東完全就是給編譯器看的。 比如@Ovrride表示這個方法是重寫了父類中的方法，而不是自定義的，所以這個時候編譯器會去檢查你的方法名是否和父類一樣，是否寫錯了。
以上是不同的概念

J. java如何自定例外

public class Vehicle {
private int wheel;

public Vehicle() { this(4);}
public Vehicle(int w) throws Exception{
if(w<1){
throw new VehicleWheelException ('Invalid wheel number!')
}

this.setWheel(w);
}

public void setWheel(int w) {
this.wheel=w;
}
public static void main(String[] args) {

Vehicle v1=new Vehicle(6);
Vehicle v2=new Vehicle(-1);
}
class VehicleWheelException extends Execption{

VehicleWheelException(String msg){
supper(msg);
}

public String toString(){
return supper.getMessage();

}
public String getMessage(){
return supper.getMessage();
}

}

大概是這樣