⑴ java中怎样创建一个类有那些方法,请举例说明.谢谢!
1、定义一个类，class A={}，然后创建这个类对象，A a = new A();有没有参数看你类定义的构造函数；
2、继承java已有的类，以异常类为例，class A extends Exception{}
3、实现java已有接口或者抽象类，class A implements Runnable{}
4、单继承多实现，class A extends B implements C,D{}
⑵ java如何定义一个类，创建它的成员变量和方法
建立一个Javaproject——点右键新建一个类，类名字最好是大写开头，LZ 我给你写一个简单的类x0dx0apublic class Test{x0dx0a//定义成员变量x0dx0aint width=10;x0dx0aint height=10;x0dx0a// 成员方法x0dx0apublic area(){x0dx0a return width*height ;x0dx0a }x0dx0a}
⑶ 昆明Java培训：Java如何创建不可变类
⑷ java中如何以给定的字符串为名字创建某个类的实例 可以用反射根据给定的类名来动态生成实例 比如你定义了一个类 然后使用如下代码创建这个类的一个实例 这个instance就是需要的结果 ⑸ java如何创建一个类的对象
Java创建一个类的对象通过new关键字创建： ⑹ 怎么用"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 定义类 如何写
类是一种引用数据类型。类为对象的模板，简单的说就是分类。 ⑻ java类创建方法
有4种显式地创建对象的方式： ⑼ Java如何创建一个类
定义一个类，class A={}，然后创建这个类对象，A a = new A();有没有参数看你类定义的构造函数； 例代码如下： ⑽ 如何创建JAVA类，如下
1）new--->project--->Java Project --> Project Name 中写工程
不可变类：当你获得这个类的一个实例引用时，你不可以改变这个实例的内容。
那么，什么是不可变对象?一旦一个类的实例化对象被创建并初始化，那么它就不可以被改变。
我们可以调用访问器方法(getter)，复制对象，或者传递对象，但是不允许任何方法改变这个对象的状态。
包装类(e.g.Integer或Float)和String类是不可变类的代表。
访问器方法(accessormethod)：对成员变量做出访问的方法，e.g.getter()方法。
修改器方法(mutatormethod)：对成员变量做出修改的方法，e.g.setter()方法。
定义一个不可变类如果我们要自己创建一个不可变类，需要遵守下面的规则：将成员变量(field：在一些书中也翻译为域)声明成final并在构造器中初始化。
对于基本类型的成员变量，用final修饰，一旦它被初始化，就不能被改变了。
而对于引用类型的成员变量，不能够改变它的引用。
成员变量如果被声明称final，那么构建对象时，必须要初始化这样的域引用类型是可变的，我们需要采取一些措施来保证它的不可变性。
为什么?如果我们只是声明了一个final的可变引用类型，那么这个引用可以去引用外部的类，或者被其他外部类引用。
在这种情况下，我们要做到：1.这些方法不会改变这些可变对象中的内容2.不要将这些引用分享到外部供其他类使用，例如，如果对成员变量的引用是可以被其他类改变的，那么这些外部类就可以改变这个类中的内容。
3.如果必须要返回一个引用，那么就返回一个对象的深度拷贝，这样尽管返回的对象内容改变了，但也保存着原始的内容。
只提供访问器方法(i.e.getter方法)不提供修改器方法(i.e.setter方法)如果一定要改变这个对象的内容，那就创建一个新的不可变对象内容做相应的修改，返回修改后的对象的引用声明类是final的。
如果一个类可以被继承，那么它子类就可以重载它的方法，并且修改成员变量JavaAPI中不可变类的例子让我们来回顾一下String类，用它来理解上述的几个方面在String类实现中的体现：所有在Stirng类中成员变量都被声明成private，这些成员变量都在构造器中在构建对象时被初始化。
trimconcatsubstring都可以改变String的对象，为了保证String的不可变性，这些方法都返回的是一个改变相应内容后新的对象。
string类被声明称final，所以任何类都不能继承，重载它的方法。
自己实现一个不可变类接下来我们自己实现一个不可变类ImmutableCircle。
//ImmutableCircle.java//{privateintxPos,yPos;publicPoint(intx,inty){xPos=x;yPos=y;}publicStringtoString(){return"x="+xPos+",y="+yPos;}intgetX(){returnxPos;}intgetY(){returnyPos;}}//_thestateofitsobjects//{privatefinalPointcenter;privatefinalintradius;publicImmutableCircle(intx,inty,intr){center=newPoint(x,y);radius=r;}publicStringtoString(){return"center:"+center+"andradius="+radius;}publicintgetRadius(){returnradius;}publicPointgetCenter(){//returnaoftheobjecttoavoid//(center.getX(),center.getY());}publicstaticvoidmain(String[]s){System.out.println(newImmutableCircle(10,10,20));}//othermembersareelided...}上面的程序运行之后，打印：center:x=10,y=10andradius=20上面的程序体现了不可变类的以下几点：·这个类被声明成final，不可以被继承，也不可以重载它的方法·这个类的成员变量都是final并且是私有的·因为成员变量center是一个引用类型，是可变的，所以在他的getter方法中，返回的是对point对象的拷贝设计一个不可变的类最关键的一点：要注意引用类型的成员变量，如果成员变量的类型是可变的引用类型，就必须要采取必要的措施来保护这个成员变量不会被修改不可变类不足的地方不可变对象同样也有不足的地方。
为了保证不可变性，不可变类中的方法会创建出一定量的对象的拷贝。
例如，在上面的代码中，每次调用getcenter方法都会新建并返回一个point对象的拷贝。
而假如我们只需要调用一次，返回一个point对象，就没必要费尽心神的去设计一个不可变类，仅仅只需要一个可变的immutablecircle类就可以了。
String类在很多应用场景中都会用到，如果我们调用String类中trim，concat，或者是在循环中调用substring方法，都会创建一个新的临时String对象。
同时，java也提供了Stringbuffer和Stringbuilder的可变类。
他们同String一样，但是却可以改变这个对象的内容。
所以，我们可以根据不同的场景使用String类或者Stringbuffer/Stringbuilder类。
总结,文章的最后还是那句话，要根据自己的实际需要，去设计代码，而不要过度设计。
packagesample;
/**
*Createdbypseudoon15-9-16.
*/
publicclassTestClass{
privateStringname;
publicTestClass(Stringname){
this.name=name;
}
@Override
publicStringtoString(){
return"TestClass{"+
"name='"+name+'''+
'}';
}
}publicstaticvoidmain(String[]args)throwsException{
//加载要反射的类
Classclz=Class.forName("sample.TestClass");
//找到类的构造方法
Constructorconstructor=clz.getDeclaredConstructor(String.class);
//使用找到的构造方法创建实例
Objectinstance=constructor.newInstance("Lilei");
System.out.println(instance);
}
语法如下：
类 对象 = new 类构造方法（）；
实例：
public class Person{
String name;
char sex;
int age;
public static void main(String[] args){
//在main方法完成Person类的对象person创建
Person person1 = new Person();
}
}
你明白了吗？
类的定义包括“成员变量”的定义和“方法”的定义，其中“成员变量”用于描述一类对象共同的数据结构。在Java语言中，类的成员变量的定义可以使用如下语法：
class 类名 {
成员变量类型变量名称；
………
}
类是用class关键字来定义的一种抽象数据类型，类不但定义了抽象数据类型的组成（成员变量），同时还定义了对该类型可以实施的操作（方法），类名的首字母必须大写。看如下代码定义了雇员类:
/** 定义雇员类 */
public class Emp{
String name;
int age;
char gender;
double salary;
}
在如上的实例代码中，仅仅定义了Emp类型的组成，即成员变量。该类定义了4个成员变量：String类型的name用于存放名字；int类型的age用于存放年龄；char类型的gender用于存放性别；double类型的salary用于存放工资。
1.用new语句创建对象，这是最常用的创建对象的方式。
2.运用反射手段，调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法。
3.调用对象的clone()方法。
4.运用反序列化手段，调用java.io.ObjectInputStream对象的readObject()方法.
class TestInner{
public static void main(String [] args)
{
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
}
}
在内部类（Inner Class），可以随意的访问外部类的成员，这可让我们更好地组织管理我们的代码，增强代码的可读性。
2） public class Mammal{
public int weight; //类型根据需要定
protected int height;
int legs;
private int tail;
public void printWeight() {
System.out.println(“ The weight is: ”+weight);
}
protected void printHeight() {
System.out.println(“ The heigh tis: ” + height);
}
void printLegs(){
System.out.println(“ The tail tis: ”+ tail);
}
private void printTail(){
System.out.println(“ The legs tis: ”+ legs);
}
}
3) public class Cat extends Mammal{
public void printWeight() {
System.out.println(“ The weight of the cat is: ”+weight);
}
}
哎， 没有动力了， 不想写了， 先给分吧， 有动力再写吧