java学习

最新推荐文章于 2023-07-25 09:50:35 发布

落雪snowflake

最新推荐文章于 2023-07-25 09:50:35 发布

阅读量227

点赞数

分类专栏：求职笔试+面试

本文链接：https://blog.csdn.net/weixin_38858860/article/details/99713359

版权

求职笔试+面试专栏收录该内容

27 篇文章 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 类> 对象名称
                  * 意义：只能接收该类型及其父类
                  */
           }
       }
   }

}

落雪snowflake

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
java学习

package fangFa;import java.lang.reflect.Array;import org.omg.CORBA.PUBLIC_MEMBER;import org.omg.PortableServer.ImplicitActivationPolicyOperations;/** 变量：程序运行期间，内容可以发生改变的量。* 数据类型变量名称；//创建一个...
复制链接

扫一扫