JAVA自学笔记（2）

Java跳跃级知识储备

1.Mathod新篇章

1.0进制转化（方法中的参数其实就是局部变量，在方法中定义的变量要赋初值）

import java.util.Scanner;

public class Main//进制转化
{
    public static void main(String[] args) {
        Scanner input =new Scanner(System.in);
        int num=input.nextInt();
        System.out.println(DecToHex(num));
        String s=input.next();
        System.out.println(HexToDec(s));
    }
    public static int HexToDec(String s)
    {
        int sum=0,k=0;
        for(int i=s.length()-1;i>=0;i--)
        {
            char ch=s.charAt(i);
            if(ch>='0'&&ch<='9')
            {
                sum+=(ch-'0')*Math.pow(16, k);
            }
            else 
            {
                sum+=(ch-'A'+10)*Math.pow(16,k);
            }
            k++;
        }
        return sum;
    }
    public static String DecToHex(int num)
    {
        String s="";
        int t;
        char ch;
        while(num!=0)
        {
            t=num%16;
            if(t>=0&&t<=9)
            {
                ch=(char) (t+'0');
            }
            else 
            {
                ch=(char) (t-10+'A');
            }
            s=ch+s;
            num/=16;
        }
        return s;
    }
    }

2.0 方法重载

 重载指的是方法名称相同，参数列表不同，编译器会根据方法签名决定调用哪个方法

 注意：1.有时候调用方法会有两个或更多可能的匹配，编译器无法判断哪个更为精确，这称为歧义调用。

 2.被重载的方法必须具有不同的参数列表

import java.util.Scanner;

public class Main
{
    public static void main(String[] args) {
        Scanner input =new Scanner(System.in);
        double num1=input.nextDouble();
        double num2=input.nextDouble() ;
        System.out.println(max(num1,num2));//编译器会自己决定调用哪一个
        
    }
    public static int max(int a,int b)
    {
        return a>b ? a:b;
    }
    public static double max(double a,double b)
    {
        return a>b? a:b;
    }
}

 3.0 可变参数

、

public class Main{
    public static int size;
    public static int sum=0;
    public static void main(String[] args) {
        int method = method(19,32,27,458);//计算0-n个数的和
        System.out.println(sum);//536
        System.out.println(size);//4
    }

    private static int method(int...arc) {
        size=arc.length;
        for (int i : arc) {
            sum+=i;
        }
        return sum;
    }
}

　　

 

 

2.0 面向对象的思考

   万物皆对象！

   使用面向对象思想描述现实世界：基本步骤 

   1.发现类 2.找出属性（名词）3.找出行为（动词） ——数据抽象：是数据和处理方法的结合。

     如何使用这一方法（思想）看下面的一个小样例

 

public class Actor {
    public String name;
    public String sex;
    public int age ;
    public void show(){
        System.out.println(name+"	"+sex+"	"+age);
    }
}

public class Main{
    public static void main(String[] args) {
        Actor actor1=new Actor();//Actor这个类自定义出来的 需要构造新的类
        Actor actor2=new Actor();
        actor1.name="V";
        actor1.age=25;
        actor1.sex="男";
        actor1.show();
        actor2.name="JK";
        actor2.age=23;
        actor2.sex="男";
        actor2.show();
    }
}

  这种方法比较麻烦 我们可以采用构造方法 将代码简化

  修改后为 

   

public class Actor {
    public String name;
    public String sex;
    public int age ;
    public Actor(){};
    public Actor(String name1,String sex1,int age1 )
    {
        name=name1;
        sex=sex1;
        age=age1;
    }
    public void show(){
        System.out.println(name+"	"+sex+"	"+age);
    }
}

public class Main{
    public static void main(String[] args) {
        Actor actor1=new Actor("V","男",25);
        Actor actor2=new Actor("JK","男",23);
        /*
         * 如果不传参数的话就会报错 因为在原来的类中系统默认构造了一个
         * public Actor()
         * {
         * }
         * 而用户已经构造 会覆盖系统默认的 只需要在原来构造类中添加即可
         * */
        actor1.show();
        actor2.show();
    }
}

关于构造方法：

1.没有返回值类型 2.名称与类名一致.3.可以指定参数及实现重载 4.注意隐式构造和参数化构造不能共有

   

3.0 ArrayList动态数组——真香系列

敲黑板！

ArrayList不同于普通数组的最大区别是它可以更改数组的长度 操作起来便利

ArrayList如果希望存储基本类型 存储基本类型的包装类

集合也可以做参数

下面ArrayList的练习

1）存储1-33的6个随机数字 并遍历打印

import java.util.ArrayList;
import java.util.Random;

public class Practice {
    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.print(list.get(i)+" ");
        }
        
    }
}

 2)存储自定义类 题目为存储学生类型 姓名以及学生年龄

public class Student {
    private String name;
    private int age;
    public Student() {}
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
    
}

import java.util.ArrayList;

public class Practice {
    public static void main(String[] args) {
    ArrayList<Student> list=new ArrayList<>();
    Student one =new Student("金泰亨",25);
    Student two =new Student("田柾国",23);
    list.add(one);
    list.add(two);
    for(int i=0;i<list.size();i++)
    {
        Student stu=list.get(i);//放入的是学生类 拿出的也是学生类
        System.out.println("姓名："+stu.getName()+" "+"年龄："+stu.getAge());
    }
    }
}

3）筛选集合里的偶数 放到小集合里

import java.util.ArrayList;
import java.util.Random;

public class Practice {
    public static void main(String[] args) {
    ArrayList<Integer> biglist=new ArrayList<>();
    Random r=new Random();
    for(int i=0;i<100;i++)
    {
        int num=r.nextInt(101);
        biglist.add(num);
    }
        ArrayList small= getlists(biglist);
        System.out.println("小集合里的元素个数为："+small.size());
        for(int j=0;j<small.size();j++)
        {
            System.out.print(small.get(j)+" ");
        }
    }
    public static ArrayList<Integer> getlists(ArrayList<Integer> biglist)
    {
        ArrayList<Integer> small = new ArrayList<>();
        for(int i=0;i<biglist.size();i++)
        {
            int num=biglist.get(i);
            if(num%2==0)
            {
                small.add(num);
            }
        }
        return small;
    }
}