java，

java，

               Java常识笔记

类方法和实例方法、构造方法的区别：

类方法，有static修饰符，典型的主函数
public static void main(String[] args){}
实例方法，就是一般的方法
构造方法，没有返回值(就是连void都没有)，方法名与类名一样  

堆内存和栈内存：

堆内存：用于存放new创建的对象和数组；

两者都是用于存放数据的地方；

栈中的变量指向堆内存中的变量也就是Java中的指针；

Java中字符的输入

运用到 char i=reader.next().charAt(0);

成员方法和构造方法的区别

构造方法是初始化一个类的对象时候调用的，它没有返回值，而且名字必须与类的名字一样，而成员函数是由类对象主动调用的，使用点操作符，它有返回值
构造函数是赋予对象"生命特征"的,成员方法则是对象所具有的"行为,能力"
构造函数只有在建立对象时由系统调用的,其他任何时候你都别指望用他.

数组的学习：

一维数组的输出：一种用数组输出“Arrays.toString(a)”, 记住要要进行导入；

第二种方法用for输出格式为for(int i : a);

二维数组的输出：for(int i=0;i<a.length;i++)

{

for(int j=0;j<a[i].length;j++)

{

System.out.print(a[i][j]+" ");

}

System.out.println();////输出一列后就回车空格

 

}

用for循环，i控制行，j控制列；

数组元素的交换：

        z=a[0];

a[0]=max;

a[max_index]=a[0];

z=a[a.length-1];

a[a.length-1]=min;

a[min_index]=z;

 

数组的循环输入：

int a[]=new int[3];

System.out.println("请输入3个数。");

Scanner reader=new Scanner(System.in);

for(int i=0;i<a.length;i++)

{

           a[i]=reader.nextInt();

        }

二维数组的输入输出：

import java.util.Scanner;
public class 二维数组 {
    public static void main(String[] args) {
             System.out.println("输入你需要的阶层数：");
        Scanner scan = new Scanner(System.in);
        int n=scan.nextInt();//定义需要的阶层数n
        int[][]array=new int[n][n];//定义一个n*n的数组array
        System.out.println("输入数组的各个元素：");
        for(int i=0;i<n;i++){      //i控制行；
            for(int j=0;j<n;j++){     //j控制列；
                array[i][j]=scan.nextInt();//给数组赋值
            }
        }
        System.out.println("你输入的数组为：");
        for(int i=0;i<n;i++){    //i控制行
            for(int j=0;j<n;j++){   //j控制列；
                System.out.print(array[i][j]+"\t");
                if(j==n-1)     //换行；
                    System.out.println();
            }
        }
    }
}

随机数的产生C和Java做对比：

C语言：

#include <stdio.h>
#include <stdlib.h>
#include <time.h> //用到了time函数 
int main()
{ int i,number;
srand((unsigned) time(NULL)); //用时间做种，每次产生随机数不一样
for (i=0; i<50; i++)
{
number = rand() % 101; //产生0-100的随机数
printf("%d ", number);
} 
return 0;
}

(1) 如果你只要产生随机数而不需要设定范围的话，你只要用rand()就可以了：rand()会返回一随机数值, 范围在0至RAND_MAX 间。RAND_MAX定义在stdlib.h, 其值为2147483647。

(2) 如果你要随机生成一个在一定范围的数，你可以在宏定义中定义一个random(int number)函数，然后在main()里面直接调用random()函数：
　　例如：
rand()%100是产生0-99的随机数。

Java：

import java.util.Random;

public class RandomTest {

    public static void main(String[] args) {

        int max=20;

        int min=10;

        Random random = new Random();

        int s = random.nextInt(max)%(max-min+1) + min;

        System.out.println(s);

    }

}

random.nextInt(max)表示生成[0,max]之间的随机数，然后对(max-min+1)取模。

以生成[10,20]随机数为例，首先生成0-20的随机数，然后对(20-10+1)取模得到[0-10]之间的随机数，然后加上min=10，最后生成的是10-20的随机数

方法1
(数据类型)(最小值+Math.random()*(最大值-最小值+1))
例:
(int)(1+Math.random()*(10-1+1))
从1到10的int型随数

方法2
获得随机数
for (int i=0;i<30;i++)
{System.out.println((int)(1+Math.random()*10));}
(int)(1+Math.random()*10)
通过java.Math包的random方法得到1-10的int随机数
公式是:最小值---最大值（整数）的随机数
（类型）最小值+Math.random()*最大值

方法3
Random ra =new Random();
for (int i=0;i<30;i++)
{System.out.println(ra.nextInt(10)+1);}
通过java.util包中的Random类的nextInt方法来得到1-10的int随机数

 

生成0到1之间的任意随机小数：

生成[0,d)区间的随机小数，d为任意正的小数，则只需要将nextDouble方法的返回值乘以d即可。

[n1，n2]

也就是 ra.nextDouble() * (n2-n1)+n1

 

equals和==的区别：

1、java中equals和==的区别 值类型是存储在内存中的堆栈（简称栈），而引用类型的变量在栈中仅仅是存储引用类型变量的地址，而其本身则存储在堆中。
2、==操作比较的是两个变量的值是否相等，对于引用型变量表示的是两个变量在堆中存储的地址是否相同，即栈中的内容是否相同。
3、equals操作表示的两个变量是否是对同一个对象的引用，即堆中的内容是否相同。
4、==比较的是2个对象的地址，而equals比较的是2个对象的内容，显然，当equals为true时，==不一定为true。

例子：package shiyan6;

 

import java.util.Scanner;

 

/*Gardener类有一个方法，create()，方法体实现根据输入的值，判断输出的内容

Fruit定义为接口，主体没有任何内容。*/

public class Gardener {

Scanner reader=new Scanner(System.in);

String s;

public void create()

{

System.out.println("请输入梨，苹果，橘子，其中一类水果");

s=reader.next();

if(s.equals("苹果"))

{

new Apple();

}

else if(s.equals("梨"))

{

new Pear();

}

else if(s.equals("橘子"))

{

new Orange();

}

}

上转型对象的性质：

    对象b的上转型a的实体是有子类B创建的，但是上转型对象会失去子类B的一些属性和功能。上转型对象具有以下特点：

上转型对象不能操作子类新增加的成员变量，不能使用子类新增的方法。即为较子类B失去一些属性和功能，这些属性和功能是新增的。

上转型对象可以操作子类继承或隐藏的成员变量，也可以使用子类继承的或重写的方法。即为上转型对象可以操纵父类原有的属性和功能，无论这些方法是否被重写。

上转型对象调用方法时，就是调用子类继承和重写过的方法。而不会是新增的方法，也不是父类原有的方法。

可以将对象的上转型对象再强制转换到一个子类对象，强制转换过的对象具有子类所有属性和功能。

Static
实例化一个类，首先执行带有static关键字的代码块，然后执行没有static的代码块，接着执行构造方法
不带static的代码每次new的时候都会执行一次，带static的从加载到结束只会执行一次

new一个对象时，执行的顺序是先执行顶级父类的static代码块，再执行非static代码块，然后执行构造方法，接下来执行子类的相应代码，以此类推

将字符串转换为字节数组，在文件字节流中会用到

String s=reader.next();

byte[]b=new byte[200];

b=s.getBytes();   //将字符转换为字节数组；

例子：

/*４、从控制台输入一串字符串，将该串字符串写入到磁盘某位置上的out.txt文件中去。（可先把输入的字符串转换成字节数组）*/

import java.io.*;

import java.util.*;

public class Example11_4 {

public static void main(String Args[])

{

System.out.println("请输入一串字符，此字符将存入  out.txt文件中。");

Scanner reader=new Scanner(System.in);

String s=reader.next();

byte[]b=new byte[200];

b=s.getBytes();   //将字符转换为字节数组；

try{

FileOutputStream out=new FileOutputStream("out.txt");

out.write(b);//第一种将文字写入文件的方法；

out.write(b, 0,b.length);//第二中将文字写入文件的方法；

}

catch(IOException e)

{

System.out.println("错误："+e);

}

}

 

}

               Java常识笔记

类方法和实例方法、构造方法的区别：

类方法，有static修饰符，典型的主函数
public static void main(String[] args){}
实例方法，就是一般的方法
构造方法，没有返回值(就是连void都没有)，方法名与类名一样  

堆内存和栈内存：

堆内存：用于存放new创建的对象和数组；

两者都是用于存放数据的地方；

栈中的变量指向堆内存中的变量也就是Java中的指针；

Java中字符的输入

运用到 char i=reader.next().charAt(0);

成员方法和构造方法的区别

构造方法是初始化一个类的对象时候调用的，它没有返回值，而且名字必须与类的名字一样，而成员函数是由类对象主动调用的，使用点操作符，它有返回值
构造函数是赋予对象"生命特征"的,成员方法则是对象所具有的"行为,能力"
构造函数只有在建立对象时由系统调用的,其他任何时候你都别指望用他.

数组的学习：

一维数组的输出：一种用数组输出“Arrays.toString(a)”, 记住要要进行导入；

第二种方法用for输出格式为for(int i : a);

二维数组的输出：for(int i=0;i<a.length;i++)

{

for(int j=0;j<a[i].length;j++)

{

System.out.print(a[i][j]+" ");

}

System.out.println();////输出一列后就回车空格

 

}

用for循环，i控制行，j控制列；

数组元素的交换：

        z=a[0];

a[0]=max;

a[max_index]=a[0];

z=a[a.length-1];

a[a.length-1]=min;

a[min_index]=z;

 

数组的循环输入：

int a[]=new int[3];

System.out.println("请输入3个数。");

Scanner reader=new Scanner(System.in);

for(int i=0;i<a.length;i++)

{

           a[i]=reader.nextInt();

        }

二维数组的输入输出：

import java.util.Scanner;
public class 二维数组 {
    public static void main(String[] args) {
             System.out.println("输入你需要的阶层数：");
        Scanner scan = new Scanner(System.in);
        int n=scan.nextInt();//定义需要的阶层数n
        int[][]array=new int[n][n];//定义一个n*n的数组array
        System.out.println("输入数组的各个元素：");
        for(int i=0;i<n;i++){      //i控制行；
            for(int j=0;j<n;j++){     //j控制列；
                array[i][j]=scan.nextInt();//给数组赋值
            }
        }
        System.out.println("你输入的数组为：");
        for(int i=0;i<n;i++){    //i控制行
            for(int j=0;j<n;j++){   //j控制列；
                System.out.print(array[i][j]+"\t");
                if(j==n-1)     //换行；
                    System.out.println();
            }
        }
    }
}

随机数的产生C和Java做对比：

C语言：

#include <stdio.h>
#include <stdlib.h>
#include <time.h> //用到了time函数 
int main()
{ int i,number;
srand((unsigned) time(NULL)); //用时间做种，每次产生随机数不一样
for (i=0; i<50; i++)
{
number = rand() % 101; //产生0-100的随机数
printf("%d ", number);
} 
return 0;
}

(1) 如果你只要产生随机数而不需要设定范围的话，你只要用rand()就可以了：rand()会返回一随机数值, 范围在0至RAND_MAX 间。RAND_MAX定义在stdlib.h, 其值为2147483647。

(2) 如果你要随机生成一个在一定范围的数，你可以在宏定义中定义一个random(int number)函数，然后在main()里面直接调用random()函数：
　　例如：
rand()%100是产生0-99的随机数。

Java：

import java.util.Random;

public class RandomTest {

    public static void main(String[] args) {

        int max=20;

        int min=10;

        Random random = new Random();

        int s = random.nextInt(max)%(max-min+1) + min;

        System.out.println(s);

    }

}

random.nextInt(max)表示生成[0,max]之间的随机数，然后对(max-min+1)取模。

以生成[10,20]随机数为例，首先生成0-20的随机数，然后对(20-10+1)取模得到[0-10]之间的随机数，然后加上min=10，最后生成的是10-20的随机数

方法1
(数据类型)(最小值+Math.random()*(最大值-最小值+1))
例:
(int)(1+Math.random()*(10-1+1))
从1到10的int型随数

方法2
获得随机数
for (int i=0;i<30;i++)
{System.out.println((int)(1+Math.random()*10));}
(int)(1+Math.random()*10)
通过java.Math包的random方法得到1-10的int随机数
公式是:最小值---最大值（整数）的随机数
（类型）最小值+Math.random()*最大值

方法3
Random ra =new Random();
for (int i=0;i<30;i++)
{System.out.println(ra.nextInt(10)+1);}
通过java.util包中的Random类的nextInt方法来得到1-10的int随机数

 

生成0到1之间的任意随机小数：

生成[0,d)区间的随机小数，d为任意正的小数，则只需要将nextDouble方法的返回值乘以d即可。

[n1，n2]

也就是 ra.nextDouble() * (n2-n1)+n1

 

equals和==的区别：

1、java中equals和==的区别 值类型是存储在内存中的堆栈（简称栈），而引用类型的变量在栈中仅仅是存储引用类型变量的地址，而其本身则存储在堆中。
2、==操作比较的是两个变量的值是否相等，对于引用型变量表示的是两个变量在堆中存储的地址是否相同，即栈中的内容是否相同。
3、equals操作表示的两个变量是否是对同一个对象的引用，即堆中的内容是否相同。
4、==比较的是2个对象的地址，而equals比较的是2个对象的内容，显然，当equals为true时，==不一定为true。

例子：package shiyan6;

 

import java.util.Scanner;

 

/*Gardener类有一个方法，create()，方法体实现根据输入的值，判断输出的内容

Fruit定义为接口，主体没有任何内容。*/

public class Gardener {

Scanner reader=new Scanner(System.in);

String s;

public void create()

{

System.out.println("请输入梨，苹果，橘子，其中一类水果");

s=reader.next();

if(s.equals("苹果"))

{

new Apple();

}

else if(s.equals("梨"))

{

new Pear();

}

else if(s.equals("橘子"))

{

new Orange();

}

}

上转型对象的性质：

    对象b的上转型a的实体是有子类B创建的，但是上转型对象会失去子类B的一些属性和功能。上转型对象具有以下特点：

上转型对象不能操作子类新增加的成员变量，不能使用子类新增的方法。即为较子类B失去一些属性和功能，这些属性和功能是新增的。

上转型对象可以操作子类继承或隐藏的成员变量，也可以使用子类继承的或重写的方法。即为上转型对象可以操纵父类原有的属性和功能，无论这些方法是否被重写。

上转型对象调用方法时，就是调用子类继承和重写过的方法。而不会是新增的方法，也不是父类原有的方法。

可以将对象的上转型对象再强制转换到一个子类对象，强制转换过的对象具有子类所有属性和功能。

Static
实例化一个类，首先执行带有static关键字的代码块，然后执行没有static的代码块，接着执行构造方法
不带static的代码每次new的时候都会执行一次，带static的从加载到结束只会执行一次

new一个对象时，执行的顺序是先执行顶级父类的static代码块，再执行非static代码块，然后执行构造方法，接下来执行子类的相应代码，以此类推

将字符串转换为字节数组，在文件字节流中会用到

String s=reader.next();

byte[]b=new byte[200];

b=s.getBytes();   //将字符转换为字节数组；

例子：

/*４、从控制台输入一串字符串，将该串字符串写入到磁盘某位置上的out.txt文件中去。（可先把输入的字符串转换成字节数组）*/

import java.io.*;

import java.util.*;

public class Example11_4 {

public static void main(String Args[])

{

System.out.println("请输入一串字符，此字符将存入  out.txt文件中。");

Scanner reader=new Scanner(System.in);

String s=reader.next();

byte[]b=new byte[200];

b=s.getBytes();   //将字符转换为字节数组；

try{

FileOutputStream out=new FileOutputStream("out.txt");

out.write(b);//第一种将文字写入文件的方法；

out.write(b, 0,b.length);//第二中将文字写入文件的方法；

}

catch(IOException e)

{

System.out.println("错误："+e);

}

}

 

}