今天阿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)+1final
- 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("猫跳高");
}
}
