java学习

╰半橙微兮° 2021-10-30 00:58 254阅读 0赞

package fangFa;

import java.lang.reflect.Array;

import org.omg.CORBA.PUBLIC\_MEMBER;  
import org.omg.PortableServer.ImplicitActivationPolicyOperations;

/\*  
 \* 变量：程序运行期间，内容可以发生改变的量。  
 \* 数据类型 变量名称；//创建一个变量  
 \* 变量名称=数据值；//赋值，将右边的数据值，赋值交给左边的变量  
 \* 一步到位的格式  
 \* 数据类型 变量名称=数据值；//在创建一个变量的同事，立刻放入指定的数据值  
 \*/  
public class dem01 \{  
    public static void main(String\[\] args)\{  
        //创建一个变量  
        //格式：数据类型 变量名称；  
        int num1;  
        //格式：变量名称=数据值；  
        num1=19;  
        System.out.println(num1);  
        num1=20;  
        System.out.println(num1);  
        //格式：数据类型 变量名称 =数据值  
        int num2=25;  
        System.out.println(num2);  
        System.out.println("======");  
        byte num3=30;  
        System.out.println(num3);  
        short num5=50;  
        System.out.println(num5);  
        long num6=300000001L;  
        System.out.println(num6);  
        float num7 =2.5F;  
        System.out.println(num7);  
        double num8=1.2;  
        System.out.println(num8);  
        char zifu1='a';  
        System.out.println(zifu1);  
        boolean var1=true;  
        System.out.println(var1);  
        boolean var2=var1;  
        int num3;  
        num3=30;  
        int num4;  
        System.out.println(num4);//直接打印没有赋值变量是错误的  
        int a,b,c;  
        a=10;  
        b=20;  
        c=30;  
        System.out.println(a);  
        int x=100,y=200,z=300;  
        System.out.println(x);  
        System.out.println(3.14);  
//        自动类型转换float-->double  
        double num2=2.5F;  
         //long --->float,范围是float更大一些，符合从小到大的规则  
        float num3=30L;  
        System.out.println(num3);  
    \}  
public class DEM1\{  
    public static void main(Sring\[\] args)\{  
    //long-->>int不是从小到大  
        //不能发生自动类型转换  
        /\*  
         \* 强制类型一般不推荐使用  
         \*/  
        int num=(int)100L;  
        System.out.println(num);  
          
    \}  
\}  
/\*  
 \* char-->int 自动转换  
 \* 从小到大  
 \*/  
public class demo\{  
    public static void main(String\[\] args)\{  
        int a=20;  
        System.out.println(a\*10);  
        int x=10,y=3;  
        int result=x/y;  
        int result2=x%y;  
        System.out.println(result);  
        System.out.println(result2);  
        double result3=    x+2.5;  
        System.out.println(result3);  
        /\*  
         \* 对于字符串char提升为int再计算 对饮关系ASCII unicode;  
         \* 对于字符串String(首字母大写，并不是关键字）来说，加号代表了字符串的连接操作。  
         \*/  
        //字符串类型的变量基本使用  
        //数据类型 变量名称=数据值  
        String str1="Hello";  
        System.out.println(str1);  
        System.out.println("hello"+"world");  
        String str2="java";  
        System.out.println(str2+20);//java20  
        int num1=19;  
        System.out.println(num1);  
        num1++;  
        ++num1;  
        System.out.println(num1);  
        int num3=30;  
        int num4=40;  
        System.out.println(num4);  
        int x=10,y=29;  
        int result3=++x+y--;  
        System.out.println(result3);  
        /\*  
         \* +=    a=a+ 1  a+=1  
         \* -=  
         \* \*=  
         \* /=  
         \*  %=      
         \*/  
        int a=10;  
        a+=5;  
        System.out.println(a);  
        byte num=30;  
        System.out.println(true && false);  
          
        /\*  
         \* 定义一个方法的格式  
         \* public static void 方法名称()\{  
         \* 方法体  
         \* \}  
         \*/  
        public static void famer()\{  
          
          
        \}  
        public static void cook()\{  
        short byn=10;  
        short a=12  
        \}  
        public static void main(String\[\] args)\{  
        famer();  
        cook();  
        \}  
        int num=1;  
        switch(num)\{  
        case 1:  
            System.out.println("星期一");  
              
        
          
            public static int sum(int x,int y)\{  
                return x+y;  
                  
            \}  
public class demo1\{  
    public static void main（String \[\] args)\{  
          
    \}  
    public static boolean isName(byte 1,byte b)\{  
        boolean same;  
        if(a=b)  
        \{same=true;\}  
        else\{same=false;\}  
    public static void main(String \[\] args)      
    \{  
        /\*  
         \* 数组是一种引用类型，类型必须统一数组的长度在程序运行期间不可改变  
         \* 数组的初始化 ：在内存中创建一个数组 并且向其中赋予一些默认值  
         \* 两种常见的初始化方式  
         \* 动态初始化（指定长度）  
         \* 静态初始化（指定内容）  
         \* 动态初始化数组的格式  数据类型【】 数组名称=呢哇数据类型【数组长度】  
         \*  
         \*/  
    \}    \}  
\}  
for(int i -0;i<array.length;i++)\{  
    if(i==Array.getLength(1y))  
      
\}  
System.out.println(Arrays.toString(array));  
String brand;  
double price;  
String color;  
int\[\] array=\{1,2,3,4\};  
public static int getMax(int\[\] array)\{  
    int max=array\[0\];  
    for(int i=1;i<array.length;i++)\{  
        if  
    \}  
    Person person  
    public void setAge()\{  
        if(num<100&&num>9)\{  
            age=num;      
        \}else\{  
            sys  
        \}  
        public Void setMale(boolean b)\{  
            male=b;  
        \}  
        public Void isMale()\{  
            return male;  
        \}  
          
    \}  
    public int getAge()\{  
        return age;  
    \}  
    person.setAge(20);  
      
\}  
public class Person\{  
    String name;//我自己的名字  
    //参数who是对方的名字//  
    //成员变量name是自己的名字  
//    public void  sayHello(String who)\{  
//        System.out.println(who+",你好。我是"+name);  
//    \}  
    /\*  
     \* 当方法的局部变量和类的成员变量重名的时候，根据“就近原则”，优先使用局部变量。  
     \* 如果需要访问本类中的成员变量，需要使用格式：  
     \* this.成员变量；  
     \* 通过谁调用的方法，谁就是this；  
     \*  
     \*/  
    public void  sayHello(String name)\{  
        System.out.println(name+",你好。我是"+this.name);  
    \}  
\}  
public class Demo01Person\{  
    public static void main(String\[\] args)\{  
        Person person= new Person();  
        person.name="王健林";  
        person.sayHello("王思聪");  
    \}  
\}

\}  
\}  
/\*  
 \* 构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法  
 \* public 类名称（参数类型 参数名称）\{  
 \* 方法体  
 \* \}  
 \* 注意事项“  
 \* 1.构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样  
 \* 2.构造方法不要返回值，连void都不写；  
 \* 3.构造方法不能return一个具体的返回值；  
 \*/  
public class Student\{  
    public Student()\{  
        System.out.println();  
    \}  
    private String name;  
    private int age;  
    public Student(String name,int age)\{  
        this.name=name;  
        this.age=age;  
    \}  
\}

public class Student\{  
    private String name;  
    private int age;  
      
\}  
/\*  
 \* API现成的类 了解常用的类JDK\_API\_1.6\_ZH\_CN.CHM  
 \*/  
/\*  
 \* Scanner 类的功能 ，可以实现键盘输入数据到程序中  看包构造方法成员方法  
 \* 1.导包  
 \* import 包路径.类名称；  
 \* 如果需要使用的目标类，和当前类位于同一个包下，则可以省略导包语句不写；  
 \* 只有java.lang包下的内容不需要导包  
 \* 2创建  
 \* 类名称 对象名=new 类名称（）；  
 \*  
 \* 3使用  
 \* 对象名.成员方法名（）  
 \* 获取键盘输入的一个int数字：int num=sc.nextInt();  
 \* 获取键盘输入的一个字符串：String str=sc.next();  
 \*  
 \*/  
import java.util.Scanner;  
import java.util.ArrayList;  
import java.util.Arrays;

//2.创建  
        //备注：System.in代表从键盘输入  
        Scanner sc=new Scanner(System.in);  
        //3.获取键盘输入的一个int数字：  
        int num=sc.nextInt();  
        System.out.println("输入的int数字是:"+num);  
          
          
    \}  
      
\}

public class Dem

int temp=a>b?a:b;  
int max=temp>c?temp:c;  
/\*  
 \* 创建对象的标准格式：  
 \* 类名称 对象名=new 类名称；  
 \* 匿名对象就是只有右边的对象，没有左边的名字和赋值运算符；  
 \* new 类名称（）；  
 \* 注意事项：匿名对象只能使用一次 。下次再用不得不再创建一个新对象  
 \* 使用建议：如果确定有一个对象只需要使用唯一的一次，就可以使用匿名对象；  
 \*  
 \*/  
public class Demo1Anonyous\{  
    public static void main(String\[\] args)\{  
        Person one=new Person();  
        one.name="高圆圆";  
        one.showName();  
        System.out.println("============");  
          
        //匿名对象  
        new Person().name="赵又廷";  
        new.Person().showName();  
          
    \}  
\}

//匿名对象方式  
int num=new Scanner(System.in).nextInt();  
methodParam(new Scanner(System.in));  
public static void methodParam(Scanner sc)\{  
    int num=sc.nextInt();  
\}

import java.util.Random;  
public class Demo01Random\{  
    public static void main(String\[\] args)\{  
        Random r=new Random();  
        int num=r.nextInt();  
        System.out.println("随机数："+num);  
    \}  
\}

public class Demo03Random\{  
    public static void main(String\[\] args)\{  
        int n=5;  
        Random r=new Random();  
        int num=r.nextInt(n)+1;  
        System.out.println("随机数："+num);      
    \}  
          
\}  
/\*用代码模拟猜数字小游戏  
 \* 思路：  
 \* 1.首先产生一个随机数字，并且一旦产生不再变化。用Random的nextInt方法  
 \* 2.需要键盘输入，所以用到了scanner  
 \* 3.获取键盘输入的数字，用scanner当中的nextInt方法  
 \* 4.已经得到了两个数字，判断（if）一下：如果太大（太小），提示太大(taixiao），并且重试。直到猜中游戏结束  
 \*  
 \* 5.重试就是再来一次，循环次数不确定，用while(true)  
 \*/  
public class Demo04RandomGame\{  
    public static void main(String\[\] args)\{  
          
        Random r=new Random();  
        int randomNum=r.nextInt(100)+1;  
        Scanner sc=new Scanner(System.in);  
        while(true)\{  
            System.out.println("请输入你的猜测随机数：");  
            int guessNum=sc.nextInt();//键盘输入猜测数字  
            if(guessNum>randomNum)\{  
                System.out.println("太大了，请重试");  
            \}else if(guessNum<randomNum)\{  
                System.out.println("太小了，请重试");  
            \}else \{  
                System.out.println("恭喜你，猜中啦");  
                break;//如果猜中不再试  
            \}      
        \}  
              
    \}  
          
\}

public class Demo04RandomGame\{  
    public static void main(String\[\] args)\{  
     Person\[\] array=new Person\[3\];  
     Person one=new Person("迪丽热巴",19);  
     Person two=new Person("古力娜扎",23);  
     Person three=new Person("马儿扎哈",23);  
      
     array\[0\]=one;  
     array\[1\]=two;  
     array\[2\]=three;  
      
     System.out.println(array\[0\]);  
     System.out.println(array\[1\]);  
     System.out.println(array\[2\]);  
      
     System.out.println(array\[1\].getName());  
      
          
          
          
          
    \}  
\}  
//ArrayList是大小可变的数组的实现，存储在内的数据称为元素。此类提供一些方法来操作内部存储的元素，ArrayList中可以不断添加元素，其大小也是自动增长  
//java.util.ArrayList <E>  
//<E>是一种指定的数据类型，叫做泛型。  
//基本格式：  
//ArrayList<String>List=new ArrayList<String>();  
/\*数组的长度不可以改变  但是ArrayList集合的数据长度可变  
 \*  
 \*/  
public class Demo04ArrayList\{  
    public static void main(String\[\] args)\{  
        //创建了一个ArrayList集合，集合名称是list，里面装的全都是String字符串类型的数据  
        //备注：从JDK1.7+开始，右侧的尖括号内部可以不写内容，但是<>本身还是要写的  
        ArrayList<String>list=new ArrayList<>();  
        System.out.println(list);/\*对于Arraylist集合来说，直接打印得到的不是地址值，而是内容 如果内容是空，得到的是中括号\[\]\*/  
          
        //向集合中添加一些数据，需要用到Add方法；  
        list.add("赵丽颖");  
//        ArrayList<E>当中的常用的方法有：  
//        public boolean add(E e):向集合中添加元素，参数类型和泛型一致。  
//        public E get(int index):从集合中获取元素，参数是索引编号，返回值就是对应位置的元素；  
//        public E remove(int index):从集合中删除元素，参数是索引编号，返回值就是被删除掉的元素；  
//        public int size():获取集合的尺寸长度，返回值是集合中包含的元素个数；  
          
    \}  
\}  
public class Demo04ArrayList\{  
    public static void main(String\[\] args)\{  
        ArrayList<String>list=new ArrayList<>();  
        boolean success=list.add("柳岩");  
        System.out.println(list);  
        System.out.println("添加动作是否成功："+success);  
        list.add("123w");  
        list.add("ew");  
        list.add("re");  
        list.add("rd");  
        //遍历集合  
          
        for (int i =0;i<list.size();i++)\{  
            System.out.println(list.get(i));  
      
    \}  
\}

/\*  
 \*泛型只能是引用类型，不能是基本类型  
 \*如果希望集合中ArrayList当中存储基本数据类型，必须使用 基本类型对应的包装类  
 \*基本类型                         包装类（引用类型，包装类都位于java.lang包下）】  
 \*byte           Byte  
 \*short          Short  
 \*int            Integer  
 \*long           Long  
 \*float          Float  
 \*double         Double  
 \*char           Character  
 \*boolean        Boolean  
 \* 从JDK1.5支持自动装箱，自动拆箱  
 \* 自动装箱：基本类型-->包装类型  
 \* 自动拆箱：包装类型-->基本类型  
 \*/

public class Demo04ArrayList\{  
    public static void main(String\[\] args)\{  
            ArrayList<Integer>list=new ArrayList<>();  
            list.add(100);  
            int num=list.get(1);  
              
    \}  
\}

public class Demo04ArrayList\{  
    public static void main(String\[\] args)\{  
            ArrayList<Integer>list=new ArrayList<>();  
            Random r=new Random()；  
            for(int i =0;i<6;i++)\{  
                int num=r.nextInt(33)+1;  
                   
                list.add(num);  
            \}  
            //遍历集合  
            for(int i =0;i<list.size();i++)\{  
            System.out.println(list.get(i));  
              
            \}  
            int num=list.get(1);  
              
    \}  
\}  
public class Demo04ArrayList\{  
    public static void main(String\[\] args)\{  
            ArrayList<Student>list=new ArrayList<>();  
            Student one=new Student("wq");  
            Student twe=new Student("wqq");  
            Student three=new Student("waq");  
            Student four=new Student("wcq");  
              
            for(int i =0;i<6;i++)\{  
                int num=r.nextInt(33)+1;  
                   
                list.add(num);  
            \}  
            //遍历集合  
            for(int i =0;i<list.size();i++)\{  
                Student stu=list.get(i);  
            System.out.println("姓名："+stu.getName()+"，年龄："+stu.getAge());  
              
            \}  
            int num=list.get(1);  
              
    \}  
\}

public class Demo04ArrayList\{  
    public static void main(String\[\] args)\{  
            ArrayList<String>list=new ArrayList<>();  
            list.add("asdq");  
            list.add("asq");  
            list.add("ahsq");  
            list.add("asgq");  
            list.add("afsq");  
            printArraylist(list);  
    \}  
            /\*  
             \* 定义方法的三要素  
             \* 返回值类型：只是进行打印，没有运算，没有结果，所以用void  
             \* 方法名称：printArrayList  
             \* 参数列表：ArrayList  
             \*  
             \*/  
    public static void printArrayList(ArrayList<string> list)\{  
        //\{10@29\}  
        System.out.print("\{");  
        for(int i=0;i<list.size();i++)\{  
            String name=list.get(i);  
            if(i==list.size()-1)\{  
                System.out.println(name+"\}");  
            \}else\{  
            System.out.print(name+"@");  
            \}  
        \}  
    \}  
            for(int i =0;i<6;i++)\{  
                int num=r.nextInt(33)+1;  
                   
                list.add(num);  
            \}  
            //遍历集合  
            for(int i =0;i<list.size();i++)\{  
                Student stu=list.get(i);  
            System.out.println("姓名："+stu.getName()+"，年龄："+stu.getAge());  
              
            \}  
            int num=list.get(1);  
              
    \}  
\}  
/\*  
 \* 用一个大集合存入20个随机数字，然后筛选其中的偶数元素，放到小集合中，用自定义的方法  
 \* 分析：  
 \* 1需要创建一个打集合，用来存储int数字：<Integer>  
 \* 2.随机数字用Random nextInt  
 \* 3.循环20次，把随机数字放入大集合：for循环/add方法  
 \* 4.定义一个方法，用来进行筛选；  
 \*    三要素：  
 \*    返回值类型：ArrayList小集合（里面元素个数不确定）  
 \*    方法名称：getSmallList  
 \*    参数列表：ArrayList大集合（装着20个随机数字）  
 \* 5.判断（if）是偶数：num%2==0  
 \* 6.如果是偶数，就当到小集合，否则不放/  
 \*/  
public class Demo04ArrayList\{  
    public static void main(String\[\] args)\{  
            ArrayList<Integer> bigList=new ArrayList<>();  
            Random r=new Random();  
            for(int i=0;i<20;i++)\{  
                int num=r.nextInt(100)+1;  
                bigList.add(num);  
            \}  
        Arraylist<Integer> smallList=getSmallList(bigList);  
        for(int i=0;i<smallList.size();i++)\{  
            System.out.println(smallList.get(i));  
        \}  
    \}  
    //这个方法，接收大集合参数，返回小集合结果  
    public static ArrayLiat<integer> getSmallList(ArraryList<Integer>bigList)\{  
        //创建一个小集合，用来装偶数结果  
        ArrayList<Integer> smallList=new ArrayList<>();  
        for(int i=0;i<bigList.size();i++)\{  
            int num=bigList.get(i);  
            if(num%2==0)\{  
                smallList.add(num);  
            \}  
                \}  
        return smallList;  
          
\}  
//使用空参构造  
String str1=new String();  
System.out.println("第一个字符串："+str1);  
//根据字符数组创建字符串  
char\[\] charArray=\{'A','B'\};  
String str2=new String(charArray);  
System.out.println("第二个字符串："+str2);  
//根据字节数组创建字符串  
byte\[\] byteArray=\{97,98\};  
String str3=new String(byteArray);  
System.out.println("第san个字符串："+str3);  
/\*  
 \* String当中与获取相关的常用方法有：  
 \* public int length():获取字符串当中含有字符的个数，拿到字符串的长度  
 \* public String concat(String str):将当前字符串和参数字符串拼接成为返回的新值  
 \* public char charAt(int index):获取指定索引位置的单个字符（索引从0开始）  
 \* public int indexOf(String str):查找参数字符串在本字符当中首次出现的索引位置，如果没有返回-1值；  
 \*  
 \*  
 \*/      
    \}

\}  
public class MyClass\{  
    int num;//成员变量  
    static int numStatic;//静态变量  
    //成员方法  
    public void method()\{  
        System.out.println("这是一个普通的成员方法");  
        //成员方法可以访问成员变量  
        System.out.print(num);  
        //成员方法可以访问静态变量  
        System.out.println(numStatic);  
    \}  
    public static void methodStatic()\{  
        System.out.println("这是一个静态方法");  
        //静态方法可以访问静态变量 静态方法不能用this关键字  
         System.out.println(numStatic);  
    \}  
\}  
/\*一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类的。  
 \* 如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它；  
 \* 无论是成员变量还是成员方法。如果有了static,都推荐类名称进行调用  
 \* 静态变量：类名.静态变量  
 \* 静态方法：类名称.静态方法（）  
 \*/  
public class Demo02StaticMethod\{  
    public static void main(String\[\] args)\{  
        MyClass obj=new MyClass();//首先创建对象  
        //然后才能使用没有static关键字的内容  
        obj.method();  
        //对于静态方法来说，可以通过对象名进行调用，也可以直接通过类名进行调用；  
        obj.methodStatic();  
        MyClass.methodStatic();  
    \}  
    //对于本类当中的静态方法 可以省略类名称  
\}  
/\*静态代码块  
 \* public class 类名称\{  
 \*   static\{  
 \*     
 \*   \}  
 \*   \}  
 \*   特点：当第一次用到本类时，静态代码块执行唯一的一次  
 \*   静态代码块的典型用途：  
 \*   用来一次性的对静态成员变量进行赋值。  
 \*/  
/\*  
 \* java.util.Arrays是一个与数组相关的工具类，里面提供了大量的静态方法，用来实现数组常见的操作  
 \* public static String toString(数组)：将参数数组变成字符串  
 \*/  
public class Demo01Arrays\{  
    public static void main(String\[\] args)\{  
        //将int\[\]数组按照默认格式变成字符串  
        int\[\] intArray=\{10,23,4,43\};  
        String intStr=Arrays.toString(intArray);  
        System.out.println(intStr);  
        String str="eytr68yhdhbnxjdk";  
        //如何进行升序排列：sort  
        //必须是一个数组，才能用Arrays.sort方法  
        //String-->数组，用toCharArray  
        char\[\] chars=str.toCharArray();  
        Arrays.sort(chars);  
        //需要倒序遍历  
        for(int i =chars.length-1;i>=0;i--)\{\}  
    public class Fu\{  
        int num=20;  
        public Fu()\{  
            System.out.println("父类无参构造方法");  
        \}  
        public Fu(int num)\{  
            System.out.println("父类有参构造方法");  
        \}  
        public void method()\{  
            System.out.println("父类方法");  
        \}  
    \}  
        public class Zi extends Fu\{  
            public Zi()\{  
                //super();//在调用父类无参的构造方法  
                super(20);  
                System.out.println("子类构造方法");  
            \}  
            public void methodZi()\{  
                System.out.println(super.num);  
            \}  
            public void method()\{  
                System.out.println("子类方法");  
            \}  
            System.out.println(super.num);  
            System.out.println(this.num);  
            public void methodA()\{  
                System.out.println("子类方法a");  
            \}  
            public void methodB()\{  
                methodA();  
                this.methodA();  
                System.out.println("子类方法b");  
            \}  
        \}  
    \}  
    \}  
      
\}  
/\*  
 \* 接口可以定义抽象方法  
 \* 格式：public abstract 返回值类型 方法名称（参数列表）；  
 \* 接口中的抽象方法 修饰符必须是两个固定的关键字：public abstract  
 \* 接口不能直接使用 必须有一个“实现类”来“实现”接口；  
 \* 格式：  
 \* public class 实现类名称 implements 接口名称\{\}  
 \* 接口的实现类必须覆盖重写（实现）接口中所有的抽象方法  
 \* 创建实现类对象，进行使用  
 \*/  
public interface MyInterfaceAbstract\{  
    public abstract void methodAbs();  
\}  
/\*  
 \* 对象向上转型 格式：  
 \* 父类名称 对象名 =new 子类名称（）  
 \* 对象的向下转型  
 \* 格式  
 \* 子类名称 对象名=（子类名称）父类对象;  
 \* 含义：将父类对象，还原成子类对象  
 \* Animal animal=new Cat()父类名称 对象名 =new 子类名称（）  
 \* Cat cat=(Cat)animal;子类名称 对象名=（子类名称）父类对象;  
 \* 如何才能知道一个父类引用的对象，本来时什么子类  
 \* 格式：  
 \* 对象 instanceof 类名称  
 \* 这将会得到一个boolean值结果，也就是判断前面的对象能不能当作后面类型的实例  
 \*  
 \*/  
//if(animal instanceof Dog)\{  
//       Dog dog=(Dog) animal;  
//       dog.watchHouse();  
//      \}  
/\*  
 \* 如何使用成员内部类 两种方式  
 \* 1.间接方式：在外部类的方法当中，使用内部类，然后main只是调用外部类的方法  
 \* 2.直接方式 公式  
 \* 外部类名称。内部类名称 对象名=new 外部类名称（）.new 内部类名称（）；  
 \* Body body=new Body();//外部类的对象  
 \* body.methodBody();//通过外部类的对象，调用外部类的方法，里面间接使用内部类Heart  
 \* Body.Heart heart=new Body().new Heart();  
 \* heart.beat();  
 \*/  
public class Outer\{  
    int num=10;//外部类成员变量  
    public class Inner\{  
        int num=20;//内部类成员变量  
    \}  
    public void methodInner()\{  
        int num=30;//内部类方法的局部变量  
        System.out.println(num);//局部变量就近原则  
        System.out.println(this.num);//内部类成员变量  
        /\*  
         \* 如果出现重名现象，格式：外部类名称.this.外部类成员变量  
         \*/  
        System.out.println(Outer.this.num);//外部类成员变量  
    \}  
\}  
/\*  
 \* 如果一个类时定义在一个方法内部的，那么这就是一个局部内部类  
 \* 定义格式：  
 \* 修饰符 class 外部类名称\{  
 \*    修饰符 返回值类型 外部类方法名称）（参数列表）\{  
 \*         class 局部内部类名称\{  
 \*         //...........  
 \*         \}  
 \* \}  
 \* \}  
 \*/  
public class Outer\{  
    public void methodOuter()\{  
        class Inner\{  
            int num=10;  
            public void methodInner()\{  
             sysout  
              
                  
            \}  
        \}  
    \}  
\}  
/\*左边是接口名称，右边是实现类名称，这就是多态写法  
 \* List<String> list=new ArrayList<>();  
 \*  
 \*  
 \*/  
//int avg=totalMoney/totalCount;  
//int mod=totalMoney%totalCount;  
//for(int i=0;i<totalCount-1;i++)\{  
//    list.add(avg);  
//\}  
//list.add)(avg+mod);  
//return list;  
public boolean equals(object obj)\{  
    //增加一个判断，传递的参数obj如果是null,直接返回false  
    if(obj==null)\{  
        return false;  
    \}  
    //增加一个判断，防止类型转换一次ClassCastException  
    if(obj instanceof Person)\{  
        //使用向下转型，把obj转换为person类型  
        Person p=(Person)obj;  
        //比较两个对象属性，一个对象是this（P1），一个对象是P(obj-p2)  
        boolean b=this.name.equals)(p.name)&&this.age=p.age;  
        return b;  
    \}  
    //不是Person类直接返回false  
    return false;  
\}  
/\*  
 \* java.text.DateFormat:是日期/时间格式化子类的抽象类  
 \* 作用：格式化（也就是日期->文本）、解析（文本-日期）  
 \* 成员方法：  
 \*    String format(Date date)按照指定的模式，把Date日期，格式化为符合模式的字符串  
 \*    Date parse(String source)把符合模式的字符串，解析为Date日期  
 \* DateFormat类是一个抽象类，无法直接创建对象使用，可以使用DateFormat类的子类  
 \* SimpleDateFormat    
 \*/  
   
public class Demo02StringBuilder\{  
    public static void main(String\[\] args)\{  
        StringBuilder bu=new StringBuilder();//创建StringBuilder对象  
        //使用append方法往StringBuilder中添加数据  
        StringBuilder bu2=bu.append("cdv");  
        /\*  
         \* 基本类型与字符串类型之间的相互转换  
         \* 基本类型->字符串  
         \* 1.基本类型的值+“ ”  
         \* 2.包装类的静态方法toString(参数)，不是Object类的toString()重载  
         \*   static String toString(int i)返回一个表示指定整数的String对象。  
         \* 3.String类的静态方法valueOf(参数)  
         \*    static String valueOf(int i)返回int参数的字符串表示形式。  
         \* 字符串（String）->基本类型  
         \*  使用包装类的静态方法parseXXX("字符串")；  
         \*     Integer类：static int parseInt(String s)  
         \*     Double类：static double parseDouble(String s)  
         \*/  
    \}  
\}

public class Demo1Iterator\{  
    main  
    //创建一个集合对象  
    collection<String> coll=new ArrayLit<>();  
    coll.add("23er");  
    coll.add("er");  
    coll.add("3er");  
    /\*  
     \* 多态 接口  实现类对象  
     \* Iterator<String> it=coll.iterator();  
     \* 不知道集合中有多少个元素，使用while循环 循环结束条件hasNext方法返回false  
     \*  
     \*/  
    while(it.hasNext())\{  
        String e= it.next();  
        System.out.println(e);  
    \}  
\}  
/\*  
 \* for(集合/数组的数据类型 变量名：集合名/数组名)  
 \*/  
ArrayList<String> list=new ArrayList<>();  
for(String s:list)\{  
    //ll  
\}  
int\[\] arr=\{1,2,3\};  
for(int i :arr)\{\}  
 GenericClass gc=new  GenericClass();  
 /\*  
  \* 定义含有泛型的方法：泛型定义在方法的修饰符和返回值类型之间  
  \* 格式：  
  \*   修饰符<泛型> 返回值类型 方法名（参数列表（使用泛型））\{  
  \*      方法体  
  \*   \}  
  \*/  
public class GenericMethod\{  
    public M void method01(M m)\{  
        System.out.printIn(m);  
    \}  
\}          
public class Demo03GenericMethod\{  
    public static void main()\{  
        GenericMethod gm=new GenericMethod();  
        public static void printArray(ArrayList<?>list)\{  
            ///使用迭代器遍历集合  
            Iterator<?> it=list.iterator();  
            while(it.hasNext())\{  
                 /\*  
                  \* 泛型的上限：格式 类型名称<? extends 类> 对象名称  
                  \*          意义：只能接收该类型及其子类  
                  \* 泛型的下限 格式：  
                  \* 类型名称<? super 类> 对象名称  
                  \*  意义：只能接收该类型及其父类  
                  \*/  
            \}  
        \}  
    \}  
      
\}