java类和对象的基础（笔记）

在Java类的设计中，有时希望一个类在任何时候只能有一个实例。这时可以将该类设计为单例模式（singleton）。要将一个类设计为单例模式，需要把类的构造方法的访问修饰符声明为private，然后在类中定义一个static方法，在该方法中创建类的对象。

其实这里我不懂

package demo;

public class Singleton {
    private static final Singleton INSTANCE = new Singleton();
    private int a = 0;
    private Singleton(){}
    public static synchronized Singleton getInstance(){
        return INSTANCE;
    }
    public void methodA(){
        a++;
        System.out.println("a = "+a);
    }
    public static void main(String[] args){
        Singleton sg1 = Singleton.getInstance();
        Singleton sg2 = Singleton.getInstance();
        sg1.methodA();
        sg2.methodA();
        System.out.println(sg1 == sg2);
    }
}

 递归小程序

Long.MAX_VALUE是long型数据的最大值，直接调用就可以输出

package demo;
import java.util.Scanner;
public class Demo {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        Demo d = new Demo();
        System.out.println(n+" != "+d.factor(n));
        System.out.println("max = " + Long.MAX_VALUE); //输出long型的最大数值
    }
    public static long factor(int n){
        if(n == 0) return 1;
        else
            return factor(n-1)*n;
    }
}

 递归，嵌套输出，斐波那契数列

package demo;
public class Demo {
    public static long fib(int n){
        if(n == 1 || n == 2)
            return 1;
        else
            return  fib(n-1)+fib(n-2);
    }
    public static void main(String[] args){
        for(int i = 1; i <= 20; i++){
            System.out.println("fib("+i+") = "+fib(i)); //嵌套输出 
        }
    }
}

使用类的静态变量的时候用类名调用，使用实例变量名调用也可以运行，但最好不要这样，不然很可能造成混乱，使用实例调用静态变量的话eclipse之类的IDE会警告

package demo;

public class MemberTest {
    public static void main(String[] args){
        Member m1 = new Member();
        Member m2 = new Member();
        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());
    }
}


class Member {
    int instanceVar;
    static int classVar;
    void setInstanceVar(int i){
        instanceVar = i;
        classVar = i; //实例方法可以访问静态变量
    }
    int getInstanceVar(){
        return instanceVar;
    }
    static void setClassVar(int i){
        classVar = i;
        //instanceVar = i;该方法错误，静态方法不能访问实例变量
    }
    static int getClassVar(){
        return classVar;
    }
}

Java语言规定，this只能用在非static方法（实例方法和构造方法）中，不能用在static方法中。实际上，在对象调用一个非static方法时，向方法传递了一个引用，这个引用就是对象本身，在方法体中用this表示

this关键字表示对象本身。在一个方法的方法体或参数中，也可能声明与成员变量同名的局部变量，此时的局部变量会隐藏成员变量。要使用成员变量就需要在前面加上this关键字。

this关键字的另一个用途是在构造方法中调用该类的另一个构造方法

关于this的两种使用和方法的重载的代码

package demo;

public class Demo {
    int a, b;
    Demo(int x, int y){
        a = x;
        b = y;
    }
    Demo(int x){
        a = x;
        b = 0;
    }
    Demo(){
        this(1, 0); //this关键字的另一个用途是在构造方法中调用该类的另一个构造方法
    }
    public void init(int x){
        a = x;
        int b = 5;
        System.out.println("a = "+a+", this.b = "+this.b+", b = "+b);
    }
    public void display(){
        System.out.println("a = "+a+", b = "+b);
    }
    public static void main(String[] args){
        Demo demo = new Demo();
        demo.display();
        demo.init(100);                              
        Demo demo2 = new Demo(6, 8);
        demo2.display();
    }
}

 

java中参数的传递：

当参数是引用类型的时，实际传递的是引用值，因此在方法内部可能改变原来的对象

下面程序说明了两种方法的传递

个人批注：java中可以在某个类中定义主方法，在这个主方法中可以定义这个类的对象，也可以定义其他类的对象，通过这个类的对象调用在这个类的方法的时候，传递的参数可以是其他类的对象，啊……就是这样

package demo;

public class PassByValue {
    public void change(int y){
        y = y*2;
        System.out.println("y = "+y);
    }
    public void change(Circle cc){
        cc.setRadius(100);
    }
    public static void main(String[] args){
        PassByValue pv = new PassByValue();
        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());
    }
}


package demo;
public class Circle{
    double radius;
    Circle(int x){
        radius = x;
    }
    public void setRadius(double r){
        radius = r;
    }
    public double getRadius(){
        return radius;
    }
    public double perimeter(){
        return 2*Math.PI*radius;
    }
    public double area(){
        return Math.PI*radius*radius;
    }
}

 关于静态变量的解释以及代码：

package demo;
/*
 * 静态变量：不管有多少个对象都只有一个静态变量，所有对象公用这个一个静态变量，
 * 每个对象对静态变量的改变都会影响到其他的对象
 * 
 * 访问：可以通过实例的名字来访问静态变量，但这种方法可能产生混乱的代码，
 *         最好的方法是通过类名访问静态变量
 * 
 * 其中这个例子中没构造一个对象就调用依次构造函数，构造函数中的静态变量x就加一，
 *         所以通过最终得到的x可以知道创建了多少个对象
 * */
public class Demo {
    public static void main(String[] args){
        Counter c1 = new Counter();
        System.out.println(c1.x);
        Counter c2 = new Counter();
        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);
    }
}



package demo;

public class Counter {
    int y;
    static int x;
    public Counter(){
        x++;
    }
}

实例方法和静态方法：

静态方法只能访问静态成员，不能访问非静态成员变量
非静态成员变量只能通过实例访问。但实例可以访问静态变量。

package demo;

public class Someclass {
    static int i = 48;
    int j = 5;
    public static void display(){
        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的关于类的程序了，啦啦啦&

package demo;
public class Demo {
    
    public static void main(String[] args){
        Circle cc;
        cc = new Circle();
        cc.setRadius(10);
        System.out.println("半径 = "+cc.radius);
        System.out.println("周长= "+cc.perimeter());
        System.out.println("面积 = "+cc.area());
    }
}
class Circle {
    double radius;
    public void setRadius(double r){
        radius = r;
    }
    public double getRadius(){
        return radius;
    }
    public double perimeter(){
        return Math.PI * 2 * radius;
    }    
    public double area(){
        return Math.PI * radius * radius;
    }
}

 

方法的重载的例子：

其中我看到了在本类中可以有主方法，可以在本类中的主方法中创建本类的对象。

package demo;

public class OverloadDemo {
    public void show(){
        System.out.println("No parameters.");
    }
    public void show(int a, int b){
        System.out.println("a = "+a+" b = "+b);
    }
    public void show(double d){
        System.out.println("d = "+d);
    }
    public void show(int a){
        System.out.println("a = "+a);
    }
    public static void main(String[] args){
        OverloadDemo od = new OverloadDemo();
        od.show();
        od.show(1, 2);
        od.show(1212);
        od.show(1.2345);
    }
}