在Java类的设计中，有时希望一个类在任何时候只能有一个实例。这时可以将该类设计为单例模式(singleton)。要将一个类设计为单例模式，需要把类的构造方法的访问修饰符声明为private，然后在类中定义一个static方法，在该方法中创建类的对象。
其实这里我不懂
packagedemo;public classSingleton {private static final Singleton INSTANCE = newSingleton();private int a = 0;privateSingleton(){}public static synchronizedSingleton getInstance(){returnINSTANCE;
}public voidmethodA(){
a++;
System.out.println("a = "+a);
}public static voidmain(String[] args){
Singleton sg1=Singleton.getInstance();
Singleton sg2=Singleton.getInstance();
sg1.methodA();
sg2.methodA();
System.out.println(sg1==sg2);
}
}
递归小程序
Long.MAX_VALUE是long型数据的最大值，直接调用就可以输出
packagedemo;importjava.util.Scanner;public classDemo {public static voidmain(String[] args){
Scanner sc= newScanner(System.in);int n =sc.nextInt();
Demo d= newDemo();
System.out.println(n+" != "+d.factor(n));
System.out.println("max = " + Long.MAX_VALUE); //输出long型的最大数值
}public static long factor(intn){if(n == 0) return 1;else
return factor(n-1)*n;
}
}
递归，嵌套输出，斐波那契数列
packagedemo;public classDemo {public static long fib(intn){if(n == 1 || n == 2)return 1;else
return fib(n-1)+fib(n-2);
}public static voidmain(String[] args){for(int i = 1; i <= 20; i++){
System.out.println("fib("+i+") = "+fib(i)); //嵌套输出
}
}
}
使用类的静态变量的时候用类名调用，使用实例变量名调用也可以运行，但最好不要这样，不然很可能造成混乱，使用实例调用静态变量的话eclipse之类的IDE会警告
packagedemo;public classMemberTest {public static voidmain(String[] args){
Member m1= newMember();
Member m2= newMember();
m1.setInstanceVar(100);
m2.setInstanceVar(200);
Member.setClassVar(300);
System.out.println("m1.instanceVar = "+m1.getInstanceVar());
System.out.println("m1.classVar = "+Member.getClassVar());
System.out.println("m2.instanceVar = "+m2.getInstanceVar());
System.out.println("m2.classVar = "+Member.getClassVar());
}
}classMember {intinstanceVar;static intclassVar;void setInstanceVar(inti){
instanceVar=i;
classVar= i; //实例方法可以访问静态变量
}intgetInstanceVar(){returninstanceVar;
}static void setClassVar(inti){
classVar=i;//instanceVar = i;该方法错误，静态方法不能访问实例变量
}static intgetClassVar(){returnclassVar;
}
}
Java语言规定，this只能用在非static方法(实例方法和构造方法)中，不能用在static方法中。实际上，在对象调用一个非static方法时，向方法传递了一个引用，这个引用就是对象本身，在方法体中用this表示
this关键字表示对象本身。在一个方法的方法体或参数中，也可能声明与成员变量同名的局部变量，此时的局部变量会隐藏成员变量。要使用成员变量就需要在前面加上this关键字。
this关键字的另一个用途是在构造方法中调用该类的另一个构造方法
关于this的两种使用和方法的重载的代码
package demo;public classDemo {inta, b;
Demo(int x, inty){
a=x;
b=y;
}
Demo(intx){
a=x;
b= 0;
}
Demo(){this(1, 0); //this关键字的另一个用途是在构造方法中调用该类的另一个构造方法
}public void init(intx){
a=x;int b = 5;
System.out.println("a ="+a+", this.b ="+this.b+", b ="+b);
}public voiddisplay(){
System.out.println("a ="+a+", b ="+b);
}public static voidmain(String[] args){
Demo demo= newDemo();
demo.display();
demo.init(100);
Demo demo2= new Demo(6, 8);
demo2.display();
}
}
java中参数的传递：
当参数是引用类型的时，实际传递的是引用值，因此在方法内部可能改变原来的对象
下面程序说明了两种方法的传递
个人批注：java中可以在某个类中定义主方法，在这个主方法中可以定义这个类的对象，也可以定义其他类的对象，通过这个类的对象调用在这个类的方法的时候，传递的参数可以是其他类的对象，啊……就是这样
packagedemo;public classPassByValue {public void change(inty){
y= y*2;
System.out.println("y = "+y);
}public voidchange(Circle cc){
cc.setRadius(100);
}public static voidmain(String[] args){
PassByValue pv= newPassByValue();int x = 100;
pv.change(x);
System.out.println("x = "+x);
Circle cc;
cc= new Circle(10);
System.out.println("c的半径"+cc.getRadius());
pv.change(cc);
System.out.println("c的半径"+cc.getRadius());
}
}packagedemo;public classCircle{doubleradius;
Circle(intx){
radius=x;
}public void setRadius(doubler){
radius=r;
}public doublegetRadius(){returnradius;
}public doubleperimeter(){return 2*Math.PI*radius;
}public doublearea(){return Math.PI*radius*radius;
}
}
关于静态变量的解释以及代码：
packagedemo;/** 静态变量：不管有多少个对象都只有一个静态变量，所有对象公用这个一个静态变量，
* 每个对象对静态变量的改变都会影响到其他的对象
*
* 访问：可以通过实例的名字来访问静态变量，但这种方法可能产生混乱的代码，
* 最好的方法是通过类名访问静态变量
*
* 其中这个例子中没构造一个对象就调用依次构造函数，构造函数中的静态变量x就加一，
* 所以通过最终得到的x可以知道创建了多少个对象
**/
public classDemo {public static voidmain(String[] args){
Counter c1= newCounter();
System.out.println(c1.x);
Counter c2= newCounter();
System.out.println(c1.x);
c1.x= 100;
System.out.println(c2.x);
Counter.x= 10000;
System.out.println(c2.x);
System.out.println(Counter.x);
}
}packagedemo;public classCounter {inty;static intx;publicCounter(){
x++;
}
}
实例方法和静态方法：
静态方法只能访问静态成员，不能访问非静态成员变量
非静态成员变量只能通过实例访问。但实例可以访问静态变量。
packagedemo;public classSomeclass {static int i = 48;int j = 5;public static voiddisplay(){
i= i + 100;
System.out.println("i = "+i);/*j = j + 5;
System.out.println("j = "+j);
这两句话会产生编译错误，因为静态的方法成员不能访问非静态的变量成员，
非静态的变量成员只能通过实例来访问*/}
}
static与final一起使用来定义类常量
例如，Java类库中的Math类中就定义了两个类常量：
public static final double E = 2.718281828459045 ; //自然对数的底
public static final double PI = 3.141592653589793 ;//圆周率
实例方法和静态方法的区别是：
实例方法可以对当前的实例变量进行操作，也可以对静态变量进行操作，但静态方法只能访问静态变量。实例方法必须由对象来调用
，而静态方法除了可以由对象调用外，还可以由类名直接调用。另外在静态方法中不能使用this和super关键字。
封装：
首先封装可以保护对象，防止用户直接存取对象的内部细节；其次封装也保护了客户端，防止对象实现部分的改变可能产生的副作用，即实现部分的改变不会影响到客户端的改变。 私有代码和数据仅能被对象本身的其他部分访问，不能被该对象外的任何程序部分所访问。当代码或数据是公有的时，虽然它们是定义在对象中的，但程序的其他部分也可以访问。
继承性体现了类之间的是一种(IS-A)关系。
类之间的关系还有组合、关联等。
类的修饰符 ：
类的访问修饰符可以是public或者缺省。若类用public修饰，则该类称为公共类，公共类可被任何包中的类使用。若不加public修饰符，类只能被同一包中的其他类使用。如果类使用abstract修饰符，则该类为抽象类，抽象类不能被实例化，即不能创建该类的对象。若用final修饰则该类为最终类，最终类不能被继承.
extends SuperClass
如果一个类要继承某个类需使用extends指明该类的超类，SuperClass为超类名，即定义该类继承了哪个类。如果定义类的时候没有指明所继承的超类
，那么它自动继承Object类，Object类是Java的根类。因为Java只支持单继承，所以一个类至多只能有一个超类。
implements InterfaceNameList
该选项定义该类实现哪个或哪些接口。一个类可以实现多个接口，若实现多个接口，接口名中间用逗号分开。
一个类的定义包括两个部分：类声明和类体的定义。
1. 类声明 类声明的一般格式为： [public][abstract|final] class ClassName [extends SuperClass] [implements InterfaceNameList]{
// 成员变量声明
// 成员方法声明 }
说明：
(1)类的修饰符 类的访问修饰符可以是public或者缺省。若类用public修饰，则该类称为公共类，公共类可被任何包中的类使用。若不加public修饰符，类只能被同一包中的其他类使用。如果类使用abstract修饰符，则该类为抽象类，抽象类不能被实例化，即不能创建该类的对象。若用final修饰则该类为最终类，最终类不能被继承。
(2)class ClassName 类的定义使用class 关键字，ClassName为类名，类名是由类的定义者确定的。一般类名以大写字母开头，如Circle、Employee、MyPoint、ComplexNumber等，这是Java类命名的约定(不是必须的)。
(3)extends SuperClass 如果一个类要继承某个类需使用extends指明该类的超类，SuperClass为超类名，即定义该类继承了哪个类。如果定义类的时候没有指明所继承的超类，那么它自动继承Object类，Object类是Java的根类。因为Java只支持单继承，所以一个类至多只能有一个超类。有关继承的概念将在7.1节讲述。
(4)implements InterfaceNameList 该选项定义该类实现哪个或哪些接口。一个类可以实现多个接口，若实现多个接口，接口名中间用逗号分开。
2. 成员变量的定义
类声明结束后是一对大括号，大括号括起来的部分称为类体。类体中通常定义两部分内容：成员变量(member variable)和成员方法(member method)。成员变量和成员方法称为成员(members)。成员变量提供类及对象的状态，成员方法实现类及对象的行为。 成员变量的声明格式为： [public|protected|private][static][final][transient][volatile] type variableName[=value];
说明：
(1)变量的访问修饰符 public|protected|private为变量的访问修饰符。用public修饰的变量为公共变量，公共变量可以被任何方法访问；用protected修饰的变量称为保护变量，保护变量可以被同一个包中的类或子类访问；没有使用访问修饰符，该变量只能被同一个包中的类访问；用private修饰的变量称为私有变量，私有变量只能被同一个类的方法访问。
(2)实例变量和类变量 如果变量用static修饰，则该变量称为类变量，类变量又称为静态变量。没有用static修饰的变量称为实例变量。
(3)变量类型和变量名 type variableName用来指定成员变量的类型和变量名。成员变量的类型可以是任何Java数据类型，包括基本数据类型和引用数据类型。
(4)使用final修饰的变量叫作最终变量，也称为标识符常量。常量可以在声明时赋初值，也可以在后面赋初值，一旦为其赋值，就不能再改变了。
(5)用transient 修饰的变量称为临时变量。临时变量在对象序列化时不被作为持久状态的一部分存储。
(6)用volatile修饰的变量称为共享变量。在多线程的程序中，共享变量可以被异步修改。
3. 成员方法的定义
类体中另一个重要的成份是成员方法。方法用来实现对象的动态特征，也是在类的对象上可完成的操作。 成员方法的定义包括方法的声明和方法体的定义，一般格式如下： [public|protected|private][static] [final|abstract][native][synchronized] returnType methodName ([paramList]) [throws ExceptionList]{ //方法体 }
说明：
(1)方法返回值与方法名 mehtodName为方法名，每个方法都要有一个方法名。returnType为方法的返回值类型，返回值类型可以是任何数据类型(包括基本数据类型和引用数据类型)。若一个方法没有返回值，则returnType 应为void。例如： public void setRadius(double r)
(2)方法参数 在方法名的后面是一对括号，括号内是方法的参数列表，声明格式为： type paramName1 [,type paramName2…] type为参数的类型，paramName为参数名，这里的参数称为形式参数。方法可以没有参数，也可以有一个或多个参数。如果有多个参数，参数的声明中间用逗号分开。例如： public void methodA(String s, int n) 该方法声明了两个参数，在调用方法时必须提供相应的实际参数。
3)访问修饰符 public、protected和private为方法的访问修饰符。private方法只能在同一个类中被调用，protected方法可以在同一个类、同一个包中的类以及子类中被调用，而用public修饰的方法可以在任何类中调用。一个方法如果缺省访问修饰符，则称包可访问的，即可以被同一个类的方法访问和同一个包中的类访问。
(4)实例方法和类方法 没有用static修饰的方法称为实例方法，用static修饰的方法称为类方法。关于static修饰符的使用，请参阅4.4节。
(5)final和abstract方法 用final修饰的方法称为最终方法，最终方法不能被覆盖。方法的覆盖与继承有关。用abstract修饰的方法称为抽象方法。
(6)synchronized和native修饰符 用synchronized修饰的方法称为同步方法。同步方法主要用于开发多线程的程序。有关多线程请参考第13章的内容。用native修饰的方法称为本地方法，本地方法用来调用其他语言(如C语言)编写的函数。
7)声明方法抛出异常 如果方法本身对其抛出的异常不处理，可以声明方法抛出异常。异常的声明使用throws关键字，后面给出异常名称的列表。有关异常处理请参阅第8章。
提示：在类体中，经常需要定义类的构造方法，构造方法用于创建新的对象。有些专家认为构造方法不是方法，它们也不是类的成员。
终于可以写第一个java的关于类的程序了，啦啦啦&
packagedemo;public classDemo {public static voidmain(String[] args){
Circle cc;
cc= newCircle();
cc.setRadius(10);
System.out.println("半径 = "+cc.radius);
System.out.println("周长= "+cc.perimeter());
System.out.println("面积 = "+cc.area());
}
}classCircle {doubleradius;public void setRadius(doubler){
radius=r;
}public doublegetRadius(){returnradius;
}public doubleperimeter(){return Math.PI * 2 *radius;
}public doublearea(){return Math.PI * radius *radius;
}
}
方法的重载的例子：
其中我看到了在本类中可以有主方法，可以在本类中的主方法中创建本类的对象。
package demo;public classOverloadDemo {public voidshow(){
System.out.println("No parameters.");
}public void show(int a, intb){
System.out.println("a ="+a+"b ="+b);
}public void show(doubled){
System.out.println("d ="+d);
}public void show(inta){
System.out.println("a ="+a);
}public static voidmain(String[] args){
OverloadDemo od= newOverloadDemo();
od.show();
od.show(1, 2);
od.show(1212);
od.show(1.2345);
}
}
扫一扫
1223
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
