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();
}

}

大概是这样