Java 入门

Java三大版本

JavaSE : 标准版 (桌面程序, 控制台开发)

JavaME : 嵌入式开发 (手机, 小家电)

JavaEE : E企业级开发 (web端, 服务器开发)

JDK ~ JRE ~ JVM

JDK : Java Development Kit (Java开发者工具)

JRE : Java Runtime Environment (Java运行环境)

JVM : JAVA Virtual Machine (Java虚拟机)

编译

使用javac命令将java文件编译为class文件

javac HelloWord.java

然后使用java 命令即可执行class文件

java HelloWord

包机制

• 为了更好的组织累, Java提供了包机制, 用于区别类名的命名空间
• 包语句的语法格式:

package pkg1[. pkg2[. pkg3…]];

• 导入包, 使用import 语句完成

import package1[.package2…].(classname|*);

注释

单行注释: //

多行注释: /**/

JavaDoc 文档注释

javadoc命令是用来生成自己API文档的

参数信息

• @author 作者名
• @version 版本号
• @since 指明需要最早使用的jdk版本
• @param 参数名
• @return 返回值情况
• @throws 异常抛出情况

一般写法

/*** @author xpw* @version 1.0* @since 17.0.10*/

运行命令: javadoc -encoding UTF-8 -charset UTF-8 Doc.java

可以发现在当前目录生成了很多文件

查看一下index.html, 可以看到生成的API文档

可以发现在当前目录生成了很多文件

查看一下index.html, 可以看到生成的API文档

数据类型

public class Main {public static void main(String[] args) {long a= 10L;float b=10f;double c=10d;boolean d=true;System.out.println(a);//10System.out.println(b);//10.0System.out.println(c);//10.0System.out.println(d);//true}
}

变量

常量: final

public class demo1 {static double a = 1.0;//类变量static//实列变量String name;int age;public static void main(String[] args) {int i=10;//局部变量System.out.println(i);demo1 obj = new demo1();//实例化类System.out.println(obj.age);System.out.println(obj.name);System.out.println(a);}
}

用户交互Scanner

• 作用: 通过Scanner类来获取用户的输入

• 基本语法

import java.util.Scanner;Scanner s=new Scanner(System.in);

• next() 和 nextLine()
  通过Scanner累的这两个方法获取输入的字符串, 在获取前一般需要使用hasNext()和hasNextLine()判断是否还有输入的数据

next()方法无法输出空格, 会以空白为分界

nextLine()方法可以输出一行, 以回车为分界

方法

方法的定义

修饰符 返回值类型 方法名(参数类型 参数名){...方法体...return 返回值;
}

静态方法: 在当前类可以直接调用, 在其他的类里面也可以直接通过类名.方法名调用

package base;public class FunDemo1 {public static void main(String[] args) {int sum = add(1,2); //当前类调用静态方法System.out.println(sum);}public static int add(int a,int b){return a+b;}
}

非静态方法: 如果定义的方法没有static, 要使用这个方法就需要通过new实例化对象, 然后再调用方法

package base;public class FunDemo1 {public static void main(String[] args) {FunDemo1 f = new FunDemo1();int sum = f.add(1,2); //调用非静态方法System.out.println(sum);}public int add(int a,int b){return a+b;}
}

方法的重载

• 重载就是在一个类中, 有相同的函数名称, 但形参不同的函数

• 重载规则

• • 方法的名称必须相同
  • 参数列表必须不同( 个数不同, 或类型不同, 参数排列顺序不同等)
  • 方法的返回类型可以相同也可以不同

命令行传参

package base;public class FunDemo2 {public static void main(String[] args) {for(int i=0;i<args.length;i++) {System.out.println("args["+i+"]"+args[i]);}}
}

可变参数

• JDK1.5开始, Java支持传递同类型的可变参数给一个方法
• 在方法声明中, 在指定参数类型后加一个省略号 ...
• 一个方法中只能指定一个可变参数, 它必须是方法的最后一个参数, 任何普通参数必须在它之前声明

package base;public class FunDemo3 {public static void main(String[] args) {int sum = add(1,2,3,4,5);System.out.println(sum);}public static int add(int... nums){int sum = 0;for(int j:nums) { //增强for循环sum += j;}return sum;}
}

数组

数组的声明

dataType[] 变量名; //首选方法
//即: int[] num;
或者
dataType 变量名[]; 

创建数组及初始化

使用new 操作符来创建数组

dataType[] var=new dataType[arraySize];//静态初始化
int[] a={1,2,3,4,5};//动态初始化
int[] b=new int[10]; //表示有10个元素, b[0]~b[9]默认值都为0

数组通过索引访问, 索引从0开始

获取数组长度var(变量名).length

Arrays类

• 数组的工具类 java.util.Arrays

• 可以直接使用类名进行调用

• 常用功能

• • 给数组赋值: 通过fill方法
  • 对数组排序: 通过sort方法, 按升序
  • 比较数组: 通过equals方法比较数组中元素值是否想等
  • 查找数组元素: 通过binarySearch方法能对排序好的数组进行二分查找法操作

package base;
import java.util.Arrays;public class ArrayDemo1 {public static void main(String[] args) {int[] arr={2,343,345,2,445,3,23,456,33};System.out.println(Arrays.toString(arr)); //输出数组//[2, 343, 345, 2, 445, 3, 23, 456, 33]Arrays.sort(arr); //排序System.out.println(Arrays.toString(arr));//[2, 2, 3, 23, 33, 343, 345, 445, 456]//        Arrays.fill(arr,0); //覆盖全部数组的值
//        System.out.println(Arrays.toString(arr));Arrays.fill(arr,2,5,0); //覆盖数组部分的值,2和5表示下标,0表示要覆盖的值System.out.println(Arrays.toString(arr));//[2, 2, 0, 0, 0, 343, 345, 445, 456]}
}

面向对象

构造器

IDEA的快捷键生成构造器AIt+insert

一个类什么都不写也会生成构造器，与类名相同

• 名字和类名相同
• 没有返回值
• 一旦定义了有参构造器, 无参构造器就必须显示定义

public class Person{String name;public Person(){}public Person(String name){this.name=name;}
}

作用:

• new的本质在调用构造方法
• 初始化对象的值

在new的时候会自动执行构造器里面的代码

封装

对于private等私有属性不能直接访问, 需要通过创建一些public等方法去对这些私有属性进行调用

实例化对象是无法访问私有属性的

//举例
private name;
public String getName(){return this.name;
}
public void setName(String name){this.name=name
}

实列化类通过调用 obj.getName()方法操作这些私有熟悉

继承

• 继承是类与类之间的一种关系, 除此之外, 类与类之间的关系还有依赖, 组合, 聚合等
• 继承关系的两个类, 一个是子类(派生类), 一个是父类(基类), 子类继承父类, 使用关键字extends来表示
• 子类会继承父类的所有方法 (private私有的无法被继承)
• Java中, 所有的类都默认直接或间接的继承object类, 可以使用其里面定义的方法

父类的引用可以指向子类

比如: public class Student extends Person(){}可以有: Student s1 = new Student();Person s2 = new Student(); //可以指向子类,但不能调用子类里面独有的方法Object s3 = new Student();

super

子类和父类有相同的属性和方法时, 通过super使用父类的属性或方法

//举例
public void test(String name){System.out.println(name); //所传参的值System.out.println(this.name); //当前类的值System.out.println(super.name); //父类的值}

注意点:

• • super调用父类的构造方法,必须在构造方法的第一个
  • super只能出现在子类的方法或构造方法中
  • super和this 不能同时调用构造方法

方法的重写

1. 1. 方法名必须相同
   2. 参数列表必须相同
   3. 修饰符: 范围可以扩大但不能缩小 ( public > Protected > Default > private)
   4. 抛出的异常: 范围可以被缩小但不能扩大

有static修饰的静态方法 ( 方法的调用只和左边定义的数据类型有关 )

没有static修饰的非静态方法, 可以重写

接口

• 关键词: interface
• 接口中所有定义的方法都是 abstract public

抽象类: abstract关键字, 只有方法名字没有方法的具体实现

public interface UserService{void add(String name);void update(String name);
}

• 类可以实现接口: implements 接口名 (可以实现多个接口)
• 需要重写接口中的所有方法

public interface TimeService{int timer();
}
public class UserServiceImpl implments UserService TimeService{@Overridepublic void add(String name){}@Overridepublic void update(String name){}@Overridepublic int timer(){}
}

内部类

public class out {public int id =999;public  void outer(){System.out.println("outer method");}public class in{public void inner(){System.out.println("inner method");}}}

调用

public class Doc{public static void main(String[] args) {out a = new out();//外部类实例化out.in b = a.new in();//调用内部类b.inner();}
}

也可以使用这种内部类的方法实现对私有熟悉的调用

public class out {private int id =999;public class in{public void getid(){System.out.println(id);}}}

调用

public class Doc{public static void main(String[] args) {out a = new out();out.in b = a.new in();b.getid();}
}

异常

try:监控区域

catch:捕获异常

finally无论结果都会执行

package base;public class Main {public static void main(String[] args) {int a=1;int b=0;try{System.out.println(a/b);}catch(ArithmeticException e){System.out.println(e.getMessage());}finally{System.out.println("finally");}}
}

throw: 在方法中主动抛出异常

throw new ArithmeticException();

throws: 在类主动抛出异常

public void test(int a,int b) throws ArithmeticException{}

自定义异常

public class myexception extends Exception{private int details;public myexception() {this.details = 0;}@Overridepublic String toString() {return "myexception{" +"details=" + details +'}';}
}