java随笔1

忘是亡心i 2022-07-13 01:15 154阅读 0赞

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;i<n;i++)\{  
a\[i\]=input.nextInt();  
for(j=2;j<a\[i\];j++)\{  
if(a\[i\]%j==0)\{  
System.out.println("No");  
break;  
\}  
\}  
if(j==a\[i\])\{  
System.out.println("Yes");  
\}  
\}  
input.close();  
\}  
\}\*/  
/\*  
public class Main\{  
public static void main(String\[\] args)\{  
for(int i=0;i<35;i++)\{  
for(int j=0;j<=50;j++)\{  
for(int k=0;k<50;k++)\{//1k为1担  
if((3\*i+2\*j+k==100)&&(i+j+2\*k==100))\{  
System.out.println(i+","+j+","+2\*k);  
\}  
\}  
\}  
\}  
\}  
\}  
\*/  
/\*  
import java.util.\*;  
import java.io.BufferedInputStream;//重点记  
public class Main\{  
public static int fun(int n)\{  
int flag=1;  
for(int i=2;i<=Math.sqrt(n);i++)\{  
if(n%i==0)  
flag=0;  
\}  
return flag;  
\}  
public static void main(String\[\] args)\{  
Scanner scan=new Scanner(new BufferedInputStream(System.in));  
while(scan.hasNext())\{//ctrl+z结束  相当于EOF  
int b,flag=0;  
int n=scan.nextInt();  
if(n<4||n>1000000)\{  
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();  
          
\}  
\}  
\*/  
/\*  
1. 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类  
  
  
2. 内部类的方法可以直接访问外部类的所有数据，包括私有的数据  
  
  
3. 内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便  
  
  
问：内部类有几种呢？  
  
  
答：内部类可分为以下几种：  
  
  
成员内部类  
静态内部类  
方法内部类  
匿名内部类  
\*/  
/\*  
//外部类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  
        
      // 调用show方法  
si.show();  
\}  
\}  
\*/  
//由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符。