java基础

一、 java中的基本类型

1. 定义类：修饰符+class+类名

　　public class Test{ }

2. 定义方法：修饰符+返回值+方法名+参数

　　public void func1(int num){ }        ======void没有返回值

　　public int func2(){return 0;}          ======非void的必须有返回值

3. 基本类型一共有8中，char、byte、short、int、long、double、float、boolean

　　char：只有一位的字母

　　byte short int long 数字类型，分别是8 16 32 64位

　　double float 小数类型

　　boolean 布尔值

二、 java中的集合

1. List、ArrayList 相当于Python中的list

import java.util.ArrayList;
import java.util.List;

public class Test1 {
    public static void main(String[] args) {
//      定义了一个空的arraylist，类似Python的列表
        List list = new ArrayList();

//       定义一个声明元素类型的list List<?/int/String> list d= new ArrayList<?/int/String>()
//        List<Integer> list = new ArrayList<Integer>();

//        往list里添加一个元素
        list.add(1);
        list.add(22);
        list.add("mpp");
        System.out.println(list);
    }
}

输出结果如下：

[1, 22, mpp]

循环读取list的元素：

import java.util.ArrayList;
import java.util.List;

public class Test1 {
    public static void main(String[] args) {
//      定义了一个空的arraylist，类似Python的列表
        List list = new ArrayList();

//       定义一个声明元素类型的list List<?/int/String> list d= new ArrayList<?/int/String>()
//        List<Integer> list = new ArrayList<Integer>();

//        往list里添加一个元素
        list.add(1);
        list.add(22);
        list.add("mpp");
        System.out.println(list);

//      第一种循环输出list的每个元素
        for (int i =0;i<list.size();i++){
            System.out.println(list.get(i));
        }

//        第二种循环输入list的每个元素
//        for(Integer obj : list){
//            System.out.println(obj);
//        }
    }
}

运行结果：

[1, 22, mpp]
1
22
mpp

2. Map，相当于Python中的字典

import java.util.HashMap;
import java.util.Map;

public class Test1 {
    public static void main(String[] args) {
//        定义一个map，类似于Python的字典
        Map<String, String> map = new HashMap<String, String>();
//        往map中添加元素
        map.put("name", "mpp");
//        输出字典
        System.out.println(map);
//        输出某个key的值
        System.out.println(map.get("name"));
    }
}

运行结果：

{name=mpp}
mpp

3.  set，相当于把Map中的值存储，（去重），比如我们在代码里添加两个一样的元素观察

import java.util.HashMap;
import java.util.HashSet;

import java.util.Set;

public class Test1 {
    public static void main(String[] args) {
        Set<String> set = new HashSet<String>();
        set.add("1");
        set.add("1");
        set.add("2");
        System.out.println(set);

    }
}

注意观察他的运行结果，只有一个1，会自动去重的，类似于字典中不能存在相同的key

[1, 2]

以上三个的size，相当于Python中的lenth，比如我们输入一个list，map和set的size

        System.out.println(list.size());
        System.out.println(map.size());
        System.out.println(set.size());

运行结果

3
1
2

三、java中的类和类的继承，接口和实现类接口

public class class_test01 {
//    定义一个接口P
    interface P{
        public void sout1();  //只需要定义方法名，不用是实现
        public void sout2();
    }
//    定义一个类F
    static class F{
        public void sout3(){ System.out.println("我是类F的sout3"); }
        public void sout4(){ System.out.println("我是类F的sout4"); }
    }
//    定义一个类C，继承类F，实现接口P
    static class C extends F implements P{
        public void sout1(){ System.out.println("这是在类C里实现接口P的sout1"); }
        public void sout2(){ System.out.println("这是在类C里实现接口P的sout2"); }
        public void sout4(){ System.out.println("这是在类C里重写了sout4"); }
    }
    public static void main(String[] args) {
        P p = new C();  //定义变量/实例化，这里的p只能拿到类C里实现的sout1和sout2
        p.sout1();p.sout2();
        C c = new C();  //这里c可以拿到类F和接口P中的所有sout,并且sout4是类C里重写的
        c.sout1();c.sout2();c.sout3();c.sout4();
        F f = new F();  //这里f只能拿到类F中的sout3和sout4
        f.sout3();f.sout4();
    }
}

运行结果

这是在类C里实现接口P的sout1
这是在类C里实现接口P的sout2
这是在类C里实现接口P的sout1
这是在类C里实现接口P的sout2
我是类F的sout3
这是在类C里重写了sout4
我是类F的sout3
我是类F的sout4

 第二个具体例子：接口和实现接口的

public class class_test02 {
//    定义各一个接口，有一个发送的方法
    interface S{ public void send(String text);}
//    声明一个类实现接口，邮件发送
    static class Mail implements S{
        @Override
        public void send(String text){ System.out.println("邮件发送："+text); }
    }
//    声明一个类实现接口，短信发送
    static class Phone implements S{
        @Override
        public void send(String text){ System.out.println("短信发送："+text); }
    }

    public static void main(String[] args) {
        S mail = new Mail();
        S phone = new Phone();
        mail.send("我是邮件发送的具体内容");
        phone.send("我是短信发送的具体内容");
    }
}

运行结果

邮件发送：我是邮件发送的具体内容
短信发送：我是短信发送的具体内容

第三个具体例子：类和类的继承（子类和父类）以及子类重写父类

public class class_test03 {
    static class P{
        public void getText(){ System.out.println("person is animal"); }
        public void getAge(){ System.out.println("person is 36"); }
    }
    static class C extends P{
        public void getOther(){ System.out.println("child is baby"); }
        public void getAge(){ System.out.println("person is 10"); }
    }

    public static void main(String[] args) {
        P p = new C(); //使用P定义的变量，拿不到C的getOther方法
        p.getText();p.getAge();

        C c =new C();  //使用C定义的变量，可以拿到子类C和父类P的全部方法，如果子类重写了父类的方法，结果得到的是子类方法
        c.getOther();c.getAge();c.getText();
    }

}

运行结果

person is animal
person is 10
child is baby
person is 10
person is animal