Java基础——大杂烩

今天阿Q给大家来一节大杂烩，讲一下专题性不强的java基础知识。

main方法详解

public static void main(String[] args){} 这里面只有args能改变

• public 被jvm调用，访问权限足够大
• ​static 被jvm调用，不用创建对象，直接类名访问
• void被jvm调用，不需要给jvm返回值
• ​main 一个通用的名称，虽然不是关键字，但是被jvm识别
• String[] args 用于接收键盘录入

工具类

工具类一般在项目中是经常被使用的类，所以为了方便调用，直接把类里面的方法都写成静态的，直接让类名调用就好了。工具类里面的构造方法被私有，目的是不让外界创建工具类的对象。

//这是一个数组工具类,里面封装了查找数组最大值,打印数组,数组反转的方法
public class ArrayTool {
    //如果一个类中所有的方法都是静态的,需要再多做一步,私有构造方法,目的是不让其他类创建本类对象
    //直接用类名.调用即可
    /**
    私有构造方法
    */
    private ArrayTool(){}

    /**
    这是获取数组中最大值的方法
    @param arr 接收一个int类型数组
    @return 返回数组中最大值
    */
    public static int getMax(int[] arr) {
        int max = arr[0];           //记录第一个元素
        for (int i = 1;i < arr.length ;i++ ) {  //从第二个元素开始遍历
            if (max < arr[i]) {     //max与数组中其他的元素比较
                max = arr[i];       //记录住较大的
            }
        }
        return max;             //将最大值返回
    }

    /**
    这是遍历数组的方法
    @param arr 接收一个int类型数组
    */
    public static void print(int[] arr) {
        for (int i = 0;i < arr.length ;i++ ) {  //遍历数组
            System.out.print(arr[i] + " ");
        }
    }

    /**
    这是数组反转的方法
    @param arr 接收一个int类型数组
    */
    public static void revArray(int[] arr) {
        for (int i = 0;i < arr.length / 2 ;i++ ) {  //循环次数是元素个数的一半
            /*
            arr[0]与arr[arr.length-1-0]  交换
            arr[1]与arr[arr.length-1-1]  交换
            arr[2]与arr[arr.length-1-2]  交换
            */
            int temp = arr[i];
            arr[i] = arr[arr.length-1-i];
            arr[arr.length-1-i] = temp;
        }
    }
}

查看API 发现Math这个类是数学运算的工具类，构造方法私有的，里面全是静态的方法。

//Math.random()会生成大于等于0.0并且小于1.0的伪随机数
public static double random(); 

//1-100的随机整数  
(int)(Math.random()*100)+1

final

• final修饰的类：不能被继承
• final修饰的方法：不能被重写
• final修饰的变量是常量： 常量只能被赋值一次

注意：被final修饰的引用型变量，其里面的内容可以改变（也就是地址值不能被改变,对象中的属性可以改变）

常量：分为自面值常量和自定义常量，自面值常量：1;1.0;"abc";'a';自定义常量：就是被final修饰的变量就是自定义常量，自定义常量的命名规则是所有字母都大写，如果是多个单词，中间用 _ 隔开。

    class Demo{
        public static void main(String[] args) {

            final int A = 10;
            A = 20;         //被final修饰的变量是常量，只能被赋值一次
    
            final Student S = new Student("张三",23);
            S = new Student("李四");//被final修饰的变量是常量 只能被赋值一次

            final Student S = new Student("张三",23);
            //被final修饰的变量是常量只能被赋值一次，但是S这个地址值所指向的对象里面的内容可以改变
            S.name = "李四";  
            S.age = 14;

            Student s = new Student();
            s.eat();        //被final修饰的方法,可以被子类继承,但是不能被子类重写
        }
    }

    class Person{
        public final void eat(){
            System.out.println("吃吃");
        }
    }

    class Student extends Person{
        String name = "zhangsan" ;
        int age = 10;
        //对象中的常量,必须显示初始化,或者构造初始化，不能只使用默认初始化，所以这个地方报错
        final int hehe ;
        public Student(){}
        public Student(String name , int age){
            this.name = name;
            this.age = age;
        }
        public void study(){
            System.out.println("学生学习");
        }
    
        public void eat(){      //不能重写父类的eat() 因为父类的eat()被final修饰
            System.out.println("吃吃这是小孩说的 大人得说 吃饭");
        }

    }

抽象类

用abstract这个关键字修饰的类就叫做抽象类，用这个关键字修饰的方法并且不能有方法体就是抽象方法。

• 抽象类中不一定有抽象方法，但是有抽象方法的类势必是抽象类。
• 抽象类不能被实例化

    class Animal_test{
            public static void main(String[] args){
                Animal a = new Animal();        //报错 因为抽象类不能被实例化
                Animal a1 = new Cat();          //这样可以，这是多态
            }
        }
        abstract class Animal {                 //抽象类
            public abstract void eat();         //抽象方法              
        }
        class Cat extends Animal {
            public void eat() {             //子类重写父类的抽象方法
                System.out.println("猫吃鱼");
            }
        }

• 子类继承抽象类，要么子类是抽象类不用重写父类的抽象方法（因为子类是抽象类嘛），要么子类是非抽象类就必须全部重写父类的抽象方法。
• 抽象类的成员特点：成员变量可以有变量也可以有常量；有构造方法，是为了给子类继承父类初始化父类用的，成员方法可以是抽象方法，也可以是非抽象方法。
• abstract不能和哪些关键字共存呢？
  private：private修饰的方法是不能被继承的，所以不能被重写，而abstract强制要求子类重写，矛盾
  final：final表示最终的意思，修饰方法，不能被重写，而abstract强制要求子类重写，矛盾
  static：static是为了让所有对象共享，为了让类名调用，来执行一些方法里面的内容的，而abstract修饰方法是抽象方法 没有方法体， 那让对象共享一个没有方法体的方法没有意义。

接口

接口Interface，类与接口是实现关系类，实现接口用关键字 implements表示，接口中的方法全都是抽象方法，子类（非抽象的类）实现接口，必须全部重写里面的抽象方法。

    class Demo1_Interface {
​       public static void main(String[] args) {
​           //Inter i = new Inter();    //接口不能被实例化,因为调用抽象方法没有意义
​           Inter i = new Demo();       //父类引用指向子类对象
​           i.print();
​       }
​   }
​   interface Inter {
​       public abstract void print();//接口中的方法都是抽象的
​       public abstract void method();
​   }

​   class Demo implements Inter {
​       public void print() {           //非抽象的类实现接口，必须全部重写里面的抽象方法
​           System.out.println("print");
​       }
​       public void method(){
​           System.out.println("method");
​       }
​   }

• 接口中的成员特点

  成员变量： 接口里面的变量全都是常量，因为前面默认都加了 public static final

  interface Inter {
    int a;              //报错 因为a是常量 必须显示初始化
    int b =10;          //b也是常量 因为前面有默认修饰符 public static final
  }
  

  构造方法：没有构造方法
  成员方法：接口里面的方法都是抽象方法，前面都有默认修饰符 public abstract

• 类与类，类与接口，接口与接口的关系

  类与类：继承关系 ，可以单继承，也可以多层继承，不能多继承
  类与接口：实现关系，可以单实现，也可以多实现
  接口与接口： 继承关系，可以单继承，也可以多继承

案例：

​ /*

​ 动物类：姓名，年龄，吃饭，睡觉。

​ 猫和狗

​ 动物培训接口：跳高
​ */

    class Test1_Animal {
​       public static void main(String[] args) {
​           Cat c = new Cat("加菲",8);
​           c.eat();
​           c.sleep();

​           JumpCat jc = new JumpCat("跳高猫",3);
​           jc.eat();
​           jc.sleep();
​           jc.jump();
​       }
​   }

abstract class Animal {
    private String name;                //姓名
    private int age;                //年龄

    public Animal() {}              //空参构造

    public Animal(String name,int age) {        //有参构造
        this.name = name;
        this.age = age;
    }

    public void setName(String name) {      //设置姓名
        this.name = name;
    }

    public String getName() {           //获取姓名
        return name;
    }

    public void setAge(int age) {           //设置年龄
        this.age = age;
    }

    public int getAge() {               //获取年龄
        return age;
    }

    public abstract void eat();         //吃饭

    public abstract void sleep();           //睡觉
}

interface Jumping {                 //跳高的接口
    public void jump();
}

class Cat extends Animal {
    public Cat() {}                 //空参构造

    public Cat(String name,int age) {//有参构造
        super(name,age);
    }

    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void sleep() {
        System.out.println("侧着睡");
    }
}

class JumpCat extends Cat implements Jumping {
    public JumpCat() {}             //空参构造

    public JumpCat(String name,int age) {       //有参构造
        super(name,age);
    }

    public void jump() {
        System.out.println("猫跳高");
    }
}

好了今天就先说到这了，明天继续。想了解更多学习知识，请关注微信公众号“阿Q说”，获取更多学习资料吧！你也可以后台留言说出你的疑惑，阿Q将会在后期的文章中为你解答。每天学习一点点，每天进步一点点。