java随笔1-蒲公英云

package b;
import java.io.BufferedInputStream;
/*
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner input=new Scanner(System.in);
int a,b;
a=input.nextInt();
b=input.nextInt();
System.out.println(a+b);
input.close();
}
}*/
/*import java.util.*;
public class Main{
public static void main(String[] args){
Scanner input=new Scanner(System.in);
double d;
double s=0;
int k=1;
int n=input.nextInt();
for(int i=1;i<=n;i++){
d=1.0/(double)(i);
s+=d*k;
k=-k;
}
String result=String.format(“%.8f”, s);
System.out.println(result);
input.close();
}
}
*/
/*import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner scan=new Scanner(System.in);
int n=scan.nextInt();
for(int i=1;i<=n;i++){
System.out.println(i*i);
}
input.close();
}
}*/
/*import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner input=new Scanner(System.in);
int n=input.nextInt();
int[]a=new int[n];
for(int j,i=0;i1000000){
break;
}
for(int i=2;i<=n/2;i++){
if(fun(i)==1){
b=n-i;
if(fun(b)==1){
System.out.println(n+”=”+i+”+”+b);
flag=1;
}
}
}
if(flag==0)
System.out.println(“No answer”);
System.out.println();
}
scan.close();
}
}
*/
/*import java.util.*;
import java.io.BufferedInputStream;
public class Main{
public static int fun(int n){
int s=1;
for(int i=1;i<=n;i++){
s=s*i;
}
return s;
}
public static void main(String[] args){
Scanner scan=new Scanner(new BufferedInputStream(System.in));
while(scan.hasNext()){
int n=scan.nextInt();
int m=scan.nextInt();
if(n==0&&m==0)
break;
fun(n);
fun(m);
System.out.println((double)(fun(m))/fun(n)/(fun(m-n)));
}
}
}*/
/*
//导入Arrays类
import java.util.Arrays;
public class Main {
public static void main(String[] args) {

// 定义一个字符串数组
String[] hobbys = { “sports”, “game”, “movie” };

// 使用Arrays类的sort()方法对数组进行排序
Arrays.sort(hobbys);
// 使用Arrays类的toString()方法将数组转换为字符串并输出
System.out.println(Arrays.toString(hobbys));
}
}*/
/*
public class Main {// 类对像方法

public static void main(String\[\] args) \{

// 创建对象，对象名为lin
Main lin=new Main();

// 调用方法
lin.showMyLove();
}

/*
* 定义无参无返回值的方法
/
public void showMyLove() {
System.out.println(“我爱慕课网!”);
}
}*/
/*
public class Main {

//完成 main 方法  
public static void main(String\[\] args) \{  
    // 创建对象，对象名为hello

Main hello = new Main();

    // 调用方法并将返回值保存在变量中  
    int maxScore=hello.getMaxAge();

// 输出最大年龄
System.out.println(“最大年龄为：” + maxScore);
}

/
* 功能：输出学生年龄的最大值
* 定义一个无参的方法，返回值为年龄的最大值
* 参考步骤：
* 1、定义一个整形数组 ages ，保存学生年龄，数组元素依次为 18 ,23 ,21 ,19 ,25 ,29 ,17
* 2、定义一个整形变量 max ,保存学生最大年龄，初始时假定数组中的第一个元素为最大值
* 3、使用 for 循环遍历数组中的元素，并与假定的最大值比较，如果比假定的最大值要大，则替换当前的最大值
* 4、使用 return 返回最大值
*
/
public int getMaxAge() {

int \[\]ages=new int\[\]\{18,23,21,19,25,29,17\};  
int max=ages\[0\];  
for(int i=0;i<7;i++)\{  
    if(ages\[i\]>max)  
    max=ages\[i\];  
\}  
return max;

}
}
*/
/*
//方法的重载
public class Main {
public static void main(String[] args) {

// 创建对象
Main hello = new Main();

// 调用无参的方法
hello.print();

// 调用带有一个字符串参数的方法
hello.print(“hello linxing”);

// 调用带有一个整型参数的方法
hello.print(80);
}

public void print() {
System.out.println(“无参的print方法”);
}

public void print(String name) {
System.out.println(“带有一个字符串参数的print方法，参数值为：” + name);
}

public void print(int age) {
System.out.println(“带有一个整型参数的print方法，参数值为：” + age);
}
}
*/
/*
//随机数

import java.util.Arrays;
public class Main {
public static void main(String[] args) {

     // 创建对象，对象名为hello  
Main hello = new Main();  
    // 调用方法并将返回值保存在变量中

int[] nums = hello.getArray(8);

    // 将数组转换为字符串并输出

System.out.println(Arrays.toString(nums));
}

/*
* 功能：创建指定长度的int型数组，并生成100以内随机数为数组中的每个元素赋值
* 定义一个带参带返回值的方法，通过参数传入数组的长度，返回赋值后的数组
/
public int[] getArray(int length) {
// 定义指定长度的整型数组
int[] nums = new int[length];

    // 循环遍历数组赋值

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

// 产生一个100以内的随机数，并赋值给数组的每个成员
nums[i]=(int)(Math.random()*100);

}
return nums; // 返回赋值后的数组
}
}
*/
/*
import java.util.Arrays;
public class Main{
public static void main(String[] args) {
Main lin=new Main();
lin.myPrint();
}
public void myPrint(){
int[] scores=new int[]{89,-23,64,91,119,52,73};
Arrays.sort(scores);//升序排序
for(int j=0, i=scores.length-1;i>=0;i—){
if(scores[i]>100||scores[i]<0) continue; System.out.println("第"+(j+1)+"名："+scores\[i\]); j++; if(j>=3) break;
}
}
}
*/
/*
public class Main {

// 定义静态变量，保存班级名称  
    static  String className = "JAVA开发一班";//静态属性

public static void main(String[] args) {

// 访问静态变量，输出班级名称访问静态属性可以用对像访问也可用类名直接访问
System.out.println(Main.className);
//创建对像
Main lin=new Main();
//对像访问静态属性
System.out.println(lin.className);
}
}
*/
/*
//静态方法中不能直接调用非静态成员变量，如果要调用需用类的对像来调用
//普通方法可以直接调用静态和非静态成员变量
public class Main {

// 定义静态变量score1  
static int score1 = 86;  
// 定义静态变量score2  
     int score2 = 92;   
// 定义静态方法sum，计算成绩总分，并返回总分

public static int sum() {
Main lin=new Main();
int sum=score1+lin.score2;//静态方法可直接调用静态成员变量不能调用非静态成员变量
return sum;
}

public static void main(String[] args) {

    // 调用静态方法sum并接收返回值

int allScore = sum();

System.out.println(“总分：” + allScore);
}
}
*/
/*
//静态初始化块
//静态初始化块只在类加载时执行，且只会执行一次，同时静态初始化块只能给静态变量赋值，不能初始化普通的成员变量。
//静态初始化块只在类加载时执行一次，所以当再次创建对象时并未执行静态初始化块。
public class Main {

String name; // 声明变量name

String sex; // 声明变量sex
static int age;// 声明静态变量age

// 构造方法

public Main() { //构造方法方法名同类名
System.out.println(“通过构造方法初始化name”);
name = “tom”;
}

// 初始化块

{
System.out.println(“通过初始化块初始化sex”);
sex = “男”;
}

// 静态初始化块

static {
System.out.println(“通过静态初始化块初始化age”);
age = 20;
}

public void show() {
System.out.println(“姓名：” + name + “，性别：” + sex + “，年龄：” + age);
}

public static void main(String[] args) {

    // 创建对象

Main hello = new Main();
// 调用对象的show方法
hello.show();

}
}
*/
/*

内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类

内部类的方法可以直接访问外部类的所有数据，包括私有的数据

内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便

问：内部类有几种呢？

答：内部类可分为以下几种：

成员内部类
静态内部类
方法内部类
匿名内部类
*/
/*
//外部类Main
public class Main {

// 内部类Inner，类Inner在类HelloWorld的内部
public class Inner {

// 内部类的方法
public void show() {
System.out.println(“welcome to imooc!”);
}
}

public static void main(String[] args) {

  // 创建外部类对象

Main hello = new Main();
// 创建内部类对象
Inner i = hello.new Inner();
// 调用内部类对象的方法
i.show();
}
}
*/
/*
//如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，
//如果要访问外部类的成员变量，可以使用 this 关键字外部类名.this.成员静态内部类访问外部同名外部类名.成员
//外部类Main
public class Main{

//外部类的私有属性name
private String name = “imooc”;

//外部类的成员属性
int age = 20;

//成员内部类Inner
public class Inner {
String name = “爱慕课”;
//内部类中的方法
public void show() { //内外类变量相同访问外部类用this
System.out.println(“外部类中的name：” +Main.this.name);
System.out.println(“内部类中的name：”+name);
System.out.println(“外部类中的age：” +age);
}
}

//测试成员内部类
public static void main(String[] args) {

  //创建外部类的对象

Main o = new Main ();

  //创建内部类的对象

Inner inn =o.new Inner();

  //调用内部类对象的show方法

inn.show();
}
}
*/
/*
//1、静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员的方式访问
//2、如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；
//如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员
//3、创建静态内部类的对象时，不需要外部类的对象，可以直接创建内部类对象名= new 内部类();
//外部类
public class Main {

// 外部类中的静态变量score
private static int score = 84;
//外部非静态成员变量
int a=95;
// 创建静态内部类
public static class SInner {
// 内部类中的变量score
int score = 91;

public void show() {
System.out.println(“访问外部类中的score：” +Main.score);//2
System.out.println(“访问内部类中的score：” + score);
System.out.println(“访问外部类中的a: “+new Main().a);//1
}
}

// 测试静态内部类
public static void main(String[] args) {
// 直接创建内部类的对象
SInner si=new SInner();//3