• 基础知识


    Java是OOP【面向对象】的编程语言,对象的基础理解就是他有属性和方法

    这个部分主要整理的笔记包括

    • java编译class
    • class类,类的修饰符
    • 类里的方法,方法的修饰符,方法的参数,方法的返回值
    • 基础数据类型,包装类
    • String和stringbuffer
    • arrays
    • Iterator
    • collection
    • map
    • bean对象和继承
    • interface对象和继承
    • 泛型
    • 重载和重写和多态
    • 逻辑判断
    • 错误监听

    java编译class
    我们写的代码是java后缀的文件,但是执行代码的时候经过几个过程

    • java文件的编译语法检验,写欠括号逗号是会报错的,报错会停止运行
    • 把java文件编译成class后缀文件,这个class文件就是我们经常听到的jar包,工具包,我们也可以自己写一个属于自己的jar包
    • 运行class文件

    class类

    • 类的修饰符public,有好几个修饰符,但是只要记住这个就行
      创建一个java后缀的文件
    // 文件地址,这个一般是开发工具自动给你带上的;
    package xx.xx.A;
    
    // 引入别的java文件
    import xx.xx.B;
    
    // 固定写法
    // class的名字跟文件名字一样
    // 带上public
    // 一个文件只用一个class,可以用多个,但是没人这么做
    // 这个理解成js里的function,模块化
    public class A{
       
    }
    

    类里的方法

    • 方法的修饰符public,固定写法
    • 方法的修饰符static,加上是静态方法,不加是实例方法
    public class A{
        // public的class的静态属性可以被项目的任何一个地方通过【文件名.变量名】访问和修改
        static String jtsx = "静态属性";
        // public的class的静态属性可以被项目的任何一个地方通过【new 文件名().变量名】访问,只读
        // 想要获取和修改需要通过new一个实例并且调用get和set方法,查看另一个笔记
        String slsx = "实例属性";
    
        // 执行这个文件时会自动触发的main入口方法,接入服务器后不需要,目前还是需要
        public static void main(String[] args){
            // 静态方法调用静态方法,如果是调用别的class,也是这样调用
            A.jtff()
            // 静态方法调用实例方法,如果是调用别的class,也是这样调用
            A a = new A()
            a.slff()
       }
        // 静态方法
        public static void jtff(){
            System.out.println(A.jtsx)
            // 想要获取实例,跟main一样就行
        }
        // 实例方法
        public void slff(){
           System.out.println(this.slsx)
           System.out.println(A.jtsx)
        }
    } 
    
    • 方法的参数,格式是数据类型加空格加参数名
    // xx.java
    public static void test(String str){
         System.out.println(str);
    }
    public static void test(){
         System.out.println("没有参数")
    }
    // 可以写同名方法,但是参数要不一样
    xx.test();
    xx.test("测试");
    
    // Java static方法的参数最多只能有255个,非static方法最多只能有254个
    
    • 方法的返回值,不返回一定要加void,返回就把void改成return的数据格式
    public static String test(){
         // void改成了String,不写return会报错
         return "我是返回值";
    }
    

    基础数据类型
    有八个,只需要记住三个

    int num = 1;
    double num = 1.1;
    boolean flag = true;
    
    // 包装类,虽然说Java万物皆对象,但是基础数据类型不是对象
    // 这个包装类就是把基础数据类型封装成对象
    // 为什么需要包装类,因为后面会学到一个东西叫集合,集合不能存基础数据类型,所以需要存包装类
    // 但是不需要自己去操作,java有自动的装包拆包,这里只做了解
    

    重载
    重载就是一个类写多个同名的方法,有以下的规则

    • 被重载的方法必须改变参数列表(参数个数或类型不一样);
    • 被重载的方法可以改变返回类型;
    • 无法以返回值类型作为重载函数的区分标准。
    • 被重载的方法可以改变访问修饰符;
    • 被重载的方法可以声明新的或更广的检查异常;

    字符串

    // 声明一个字符串
    String name = "pdt1997";
    // 拼接字符串
    name = name + "嘻嘻嘻";
    
    // 上面的写法最常见,但是非常的消耗内存,因为String是在创建的时候固定内存的
    // 也就是说上面的代码开辟了三块内存,pdt1997,嘻嘻嘻,pdt1997嘻嘻嘻
    // 所以要习惯使用StringBuffer
    StringBuffer s1 = new StringBuffer().append("bbb");
    s1.append("aaa");
    System.out.println(s1); //bbbaaa
    
    // 不管是那个那个创建方式,都有下面的常用方法
    // length,长度
    // indexof/lastIndexOf,返回位置
    // reverse,反转
    // insert(1, "ME") ,插入
    // split,切断,支持正则
    // replace(x,y,str) ,替换一个
    // replaceAll("\d","**")
    // Pattern.matches("^[0-9]{2}$","2223aa"); //matches 判断对不对,就是js的test
    

    Array
    Java的数组不比JS的数组,他是固定内存的,不能说添加移除的,一般用来定义固定的值比如星期一到星期天之类的,还有一个叫枚举的数据类型,跟数组一样,但是比数组更少见

    int[] arr = {1,2,3,4,5,6};
    for (int i = 0; i < arr.length; i++) {
       System.out.println(arr[i] + " ");
    }
    for(int i:arr){
       System.out.println(i);
    }
    System.out.println(arr.toString()); //toString不能少
    

    Iterator
    Iterator是一个祖宗,他有两个儿子,CollectionMap

    Collection
    Collection是个爷爷,他有三个儿子,ListSetQueue,只用list就行,其他几乎不用

    List
    list是有序列表,也就是真正的数组,他有两个儿子,LinkedListArrayList

    // LinkedList:增删改快
    // ArrayList:查询快(有索引的存在)增删改慢
    // 这两个看着用,ArrayList比较常用,比较好记
    
    List<String> list1 = new ArrayList<String>();//<规定数据的格式,不写就是默认什么格式都行>
    list1.add("12"); // 索引位置为 0
    list1.add("34"); // 索引位置为 1
    list1.add("34"); // 索引位置为 1
    list1.add(1,"56"); // 索引位置为 1 ,原本的1位置被挤掉
    // 获取索引位置
    System.out.println(list1.get(1));
    // 长度
    System.out.println(list1.size());
    // 把第零位的内容换掉
    list1.set(0,"我添加上去的"); 
    // 查找位置
    System.out.println(list1.indexOf("34"));
    // 删除某个位置
    list1.remove(0);
    System.out.println(list1);
    // 整个list清空
    list1.clear();
    System.out.println(list1);	
    
    // 遍历,for循环,冒号for查看数组,这里写一个jdk8.0之后才出现的方法
    list.forEach( item -> { System.out.print(item+" "); });
    

    list的流相关资料

    List<Person> list = new ArrayList<>();
    list.add(new Person("jack", 60));
    list.add(new Person("mike", 25));
    list.add(new Person("tom", 30));
    
    list = list.stream()
                .sorted((p1, p2) -> p1.getAge() - p2.getAge())
                .filter(person -> person.getAge() == 20)
                .limit(1)
                .skip(1)
                .map(s -> s.getName().split(" "))
                .collect(toList());
    
    // 还有reduce
    int sum = numbers.stream().reduce(0, (a, b) -> a + b);
    
    // 还有最大值最小值,分组等等
    

    Map
    这个就是JS里的对象Object,这里学HashMap就行

    Map<String,String> map = new HashMap<String,String>();
    System.out.println("HashMap元素大小:"+map.size());
    
    //元素添加,重名就替换
    map.put("hi","hello");
    map.put("my","hello");
    map.put("name","hello");
    map.put("is","hello");
    map.put("jiaboyan","hello");
    
    //元素获取:通过key获取value
    String keyValue = map.get("jiaboyan");
    
    //元素删除:
    String value = map.remove("jiaboyan");
    
    //清空所有元素:
    map.clear();
    
    //hashMap是否包含某个key:
    boolean isContain = map.containsKey("hello");
    
    //hashMap是否为空:
    boolean isEmpty = map.isEmpty();
    
    // 遍历,map的遍历不是遍历map,而是遍历map.entrySet()
    // map.entrySet()可以用for和冒号for遍历,这里展示的是jdk8.0之后的写法
    map.entrySet().forEach(
       entry -> System.out.println("key:value = " + entry.getKey() + ":" + entry.getValue())
    );
    

    bean对象

    // 在上一篇的类里的方法就创建过对象,也就是new 类名()
    // 他实际是执行了一个我们没写的,透明的方法,我们把透明的方法显示出来
    public class A{
        // 构造方法
        // 构造方法的名字是类的名字也是文件的名字
        // 他没有返回值
        // 构造函数也可以重载
        public A(){
            // 这个就是透明的,每个class自带的
            // 每个类被实例化都是执行这个方法,相当于生命周期,如果你想在初始化一个实例时执行什么,可以在这里面写
        }
    }
    

    class继承

    • 子类拥有父类非 private 的属性、方法
    • 继承只能单继承,不能多继承,但能多重继承
    public class 父类 {
    }
     
    public class 子类 extends 父类 {
    }
    

    interface接口类
    怎么理解他们存在着的意义呢,就是单纯用来被继承,限制继承,本身并没有意义

    public interface Animal {
       void eat();
    }
    

    接口的继承

    • 可以自己添加方法,但是接口内内置的方法都需要有
    • 他跟class不一样,他可以多继承
    public class Cat implements Animal{
       public void eat(){
          System.out.println("没有这个方法会报错");
       }
       public void test(){
          System.out.println("test");
       } 
    }
    
    // 接口继承接口是用 extends 
    public interface D extends Animal{ ... }
    
    // 多继承
    public class C implements A,B{ ... }
    

    类可以继承接口,接口也可以继承类,可以一直得迭代上去

    泛型
    在list和map的笔记可以看到一个单书名号,写上类型这就是泛型,泛型用于规定数据类型,包括参数包括返回值,如果没有使用泛型就需要获取到内容后强转

    // 最常使用在class和接口的封装上
    public class Generic<T extends Number>{
        private T key;
    
        public Generic(T key) {
            this.key = key;
        }
    
        public T getKey(){
            return key;
        }
    }
    
    // 上面是类上注明泛型,这个是只有某个方法注明泛型
    public class Generic2{
        public static <T> void say(T t){
      
        }
    }
    
    // 使用
    Generic<A> gen = new Generic()
    Generic2.say() //传什么都行
    

    重写

    • 在继承的前置条件下
    • 方法名、参数、返回值相同。
    • 子类方法不能缩小父类方法的访问权限。
    • 子类方法不能抛出比父类方法更多的异常(但子类方法可以不抛出异常)。
    • 方法被定义为final不能被重写
    // 普通使用方法
    class Animal{
       public void move(){
          System.out.println("动物可以移动");
       }
    }
    class Dog extends Animal{
       public void move(){
          System.out.println("狗可以跑和走");
       }
    }
    public class Test{
       public static void main(String args[]){
          Animal a = new Animal(); // Animal 对象
          Dog b = new Dog(); // Dog 对象
    
          a.move();// 执行 Animal 类的方法
          b.move();//执行 Dog 类的方法
       }
    }
    
    // super
    class Cat extends Animal{
       public void move(){
          super.move(); // 应用super类的方法
          System.out.println("猫可以跑和走");
       }
    }
    public class Test{
       public static void main(String args[]){
          Cat b = new Cat(); // Cat对象
          b.move(); // 两个都会执行
       }
    }
    

    多态
    需要继承和重写为前提

    class Animal {
        public void eat(){
            System.out.println("吃");
        };
    }
    
    class Cat extends Animal {
        //覆盖父类的eat方法,就叫做重写override,也是因为有这个才有多态的特性
        public void eat() {
            System.out.println("吃鱼");
        }
        public void work() {
            System.out.println("抓老鼠");
        }
    }
    
    class Main {
        public static void main(String[] args) {
            // 向上转型,虽然还是Animal 但是执行的是被子类重写的方法
            Animal a = new Cat(); 
            a.eat(); // 调用的是 Cat 的 eat
            // a.work(); // 调用的是 Animal 的 word ,但是没有这个方法
            
            // 向下转型就是父变成某个儿子,获得儿子的功能
            Cat c = (Cat)a; // 向下转型
            c.work(); // 调用的是 Cat 的 work
        }
    }
    

    逻辑判断
    大于小于就不说话了,就是判断字符串和数字

    // 判断字符串用equals,别用等于
    String str = "foo";
    String str1 = new String("foo");
    System.out.println(str.equals(str1));
    
    // 判断数字用等于
    
    // isBlank判断的是空,长度为0,空白字符(包括空格,制表符	,换行符
    ,换页符f,回车
    )组成的字符串
    StringUtils.isBlank(String str)
    

    错误监听

    • 用try-catch监听,可以多重监听
    • 在类里监听
    try{
       // 主动抛出错误
       throw new NullPointerException();
    }catch(Exception e){
      
    }finally{
      // 程序代码
    }
    
    
    // 自定义错误类 
    public class myException extends Exception{ ... }
    

    获取类

    Animal an = new Animal();
    // 实例的getClass方法
    System.out.println(an.getClass());
    

    其他往后看

    • 反射
    • 进程
  • 相关阅读:
    Python进阶开发之元类编程
    django相关网站
    Ubuntu下vim中文乱码
    django自定义用户表
    C# webbrowser遍历网页元素
    Delphi SetParent 嵌入其他应用程序
    C# DataGirdview手动添加数据,导出txt文件并自动对齐
    C# SetParent将其他程序嵌入自己的程序
    Delphi如何找到出错行的行数!!
    Delphi StringGrid控件的用法
  • 原文地址:https://www.cnblogs.com/pengdt/p/12240527.html
Copyright © 2020-2023  润新知