基础知识
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是一个祖宗，他有两个儿子，Collection和Map
Collection
Collection是个爷爷，他有三个儿子，List，Set，Queue，只用list就行，其他几乎不用
List
list是有序列表，也就是真正的数组，他有两个儿子，LinkedList，ArrayList
// 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，空白字符（包括空格，制表符\t，换行符\n，换页符\f，回车\r）组成的字符串
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());
其他往后看
- 反射
- 进程
