Day1

随便写一个整数，默认是int类型，如果将一个超过int范围的数赋值给一个long类型的变量

long l1 = 334254235555则会报错，因为超出了int范围。正确写法是加数后面加上L或l指定类型。

如果是任意写一个浮点数，则默认是double类型的，若要指定为float则加上f

char既是字符，又能当作数值运算。

Day2

在表达式中，小范围类型的变量，会自动转换成表达式中较大范围的类型，再参与运算。

byte、short、char —> int —>long —>float —> double

  • 表达式的最终结果类型由表达式中的最高类型决定。
  • 在表达式中，byte、short、char是直接转换成int类型参与运算的。

扩展的赋值运算符(+= -= *= /= %=)隐含了强制类型转换

&&和&区别 判断结果一样,&&短路与会提前中断。

||和|区别，判断结果一样，||短路或会提前中断。

Day3

Switch 表达式类型只能是byte、short、int、char,JDK5开始支持枚举，JDK7开始支持String,不支持double、float、long。case给出的值不能重复，且只能是字面量，不能是变量。不要忘写break。

数组

1
2
3
4
5
6
7
8
9
//静态初始化数组 定义时已确定数据
数据类型[] 数据名 = {元素1,元素2,元素3,..。};
int[] arr = {12,24,36};
//完整格式
数据类型[] 数据名 = new 数据类型[]{元素1，元素2，元素3...}
int[] arr = new int[]{12,24,36};
//动态初始化数组
数据类型[] 数据名 = new 数据类型[长度]
int[] arr = new int[3];

Day4

类默认就自带了一个无参构造器(类似C++的构造函数)

为类定义了有参数构造器，那么类默认的无参数构造器就没有了，此时如果还想用无参数构造器，就必须手写一个无参数构造器

类的属性前面加static,意为静态变量，类的静态变量是共用的，在内存中占一处空间，一般是用类名.属性名来使用。

类的方法前面加staic,意为静态方法，静态方法可以用来设计工具类，工具类中的方法都是静态方法，每个类方法用来完成一个功能，提高代码复用性。

**静态方法和实例方法的区别:**静态方法可以直接访问静态成员，但不可以访问实例成员(静态成员存储在方法区，在类加载时初始化，与类本身绑定，静态方法本身没有隐含的this引用，)

子类对象包含父类的所有成员，因为子类实例化时回调用父类的构造函数初始化父类的成员。虽然私有变量存在于子类对象中，但是子类无法通过变量名直接操作它们(需要通过父类提供的public/protected方法访问)

权限修饰符

private 本类

default(缺省) 本类、同一个包中的类

protected 本类，同一个包的类、子孙类中

public 任意位置

Day5

重写

@Override 重写标识符

子类重写Object类的toString()方法(默认返回对象地址)，以便放回对象的内容。

this()

默认情况下，子类全部构造器的第一行代码都是super()，它会调用父类的无参数构造器。

如果父类没有无参数构造器，则我们必须要在子类构造器的第一行手写super(…),去指定调用父类的有参构造器。

super构造器或this构造器必须写在构造器的第一行 并且不能同时出现

多态

多态前提:有继承/实现关系;存在父类引用子类对象；存在方法重写

1
2
3
4
5
People p1 = new Student();
p1.run();

People p2 = new Teacher();
p2.run();

Java多态表现为对象多态、行为多态(方法重写)

多态是对象、行为的多态， 方法:编译看左，左即左边的类 运行看右 成员变量:编译看左，运行也看左 这里的“左”指的是引用类型，也就是声明对象时等号左边的类型。

成员变量和方法不同，它们不具备多态性。无论运行时实际对象是什么类型，访问成员变量时，永远只看引用类型（左边）的成员变量。

多态下不能调子类独有功能 （编译器为了保证代码的安全性，只允许你调用左边引用类型所拥有的功能。)

多态好处:右边对象解耦合，便于拓展维护。定义方法时，使用父类类型形参可以接收一切子类对象，扩展性强

1
2
3
4
5
6
7
8
9
10
11
12
13
遇到的问题:

Q:Animal a1 = new Tortoise();

Tortoise t1 = a1;直接这样写为什么不行 a1难道不算Tortoise的对象吗?前面不是刚new了一遍吗

Tortoise t1 = (Tortoise) a1; 为什么必须像这样强制转换了才能用?

A:编译器的保护机制，使得开发者必须强制类型转换告诉编译器知道a1是Tortoise类型。

Animal a1 = new Tortoise();

Parrot p1 = (Parrot) a1 这样写编译时不保存，但是运行时会发现试图将Tortoise类型的对象转换成Parrot,会报错ClassCastException。

Java建议在强制转换前，应该判断对象的真实类型，再进行强制类型转换。(用instanceof)

Day6

final关键字

final修饰静态变量，这个变量今后被称为常量，常量名称建议全部大写。

被final修饰的量不能被继承

修饰基本类型变量，变量存储的数据不能被改变。

修饰引用类型变量(数组)，变量存储的地址不能被改变，但地址所指对象的内容可变。

设计模式

单例设计模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//单例设计模式
public class A{
    private static A a =new A()；
    //私有化构造器
    private A(){
    
    }
    public static A getInstance(){
        return a;
    }
}
//懒汉式单例类 延迟加载对象
public class B{
    private static B b；
    //私有化构造器
    private b(){
    }
    public static B getInstance(){
        if(b == null){
            b = new B();
        }
        return b;
    }
}

模板方法设计模式

1、定义一个抽象类。

2、在里面定义2个方法

  • 一个是模板方法：把共同的实现步骤放里面去。
  • 一个是抽象方法：不确定的实现步骤，交给具体的子类来完成。

枚举类

枚举类是final最终类不可被继承，枚举类继承java.lang.Enum类 枚举类第一行只能罗列一些常量名称，**常量回记住枚举类的一个对象。**构造器为私有，对外不能创建对象。编译器为枚举类新增了几个方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
public enum A{
    X,Y,Z;
}
Complied from "A.java"
public final class A extends java.lang.Enum<A>{
    public static fianl A X = new A();
    public static fianl A Y = new A();
    public static fianl A Z = new A();
    
    public static A[] values();
    public static A valueOf(java.lang.String);

}

抽象类

用abstract修饰；抽象方法只有方法签名，不能写方法体。

可以不写抽象方法，但有抽象方法的类必须是抽象类，类有的成员，抽象类都具备。

抽象类不能创建对象，仅作为一种特殊的父类让子类继承并实现。抽象类的子类必须重写父类的所有抽象方法，除非子类本身也被声明为 abstract

接口

使用interface关键字定义的一种结构，JDK8之前，接口中只能定义成员变量(常量)和成员方法(抽象方法)。

实现类实现多个接口，必须重写完全部接口的全部抽象方法，否则实现类需要定义成抽象类。

修饰符 class 实现类类名 implements 接口1，接口2，接口3， …{

}

接口在高版本支持默认方法，私有方法private

注意事项：

  • 接口与接口可以多继承：一个接口可以同时继承多个接口[重点]
  • 一个接口继承多个接口，如果多个接口存在方法签名冲突（方法名和参数列表相同但返回类型不同的方法)则此时不支持多继承，也不支持多实现
  • 一个类继承了父类，又同时实现了接口，如果父类中和接口中有同名的默认方法，实现类会优先用父类的
  • 一个类实现了多个接口，如果多个接口中存在同名的方法，可以不冲突，

匿名内部类

书写格式:

1
2
3
4
5
6
7
8
9
new 类或接口(参数值...){
     类体(一般是方法重写);
}

new Animal(){
 @Override
 public void cry(){
 }
};

匿名内部类本质就是一个子类，并会立即创建出一个子类对象。

匿名内部类实际上有名字(在编译后产生类文件)外部类名$编号.class

匿名类的本质是编译器自动生成一个没有名字的实现类，并直接实例化。

public static void start(Swim s)这里的s可以直接用下面这种方式传参

1
2
3
4
5
6
start(new Swim(){
    @Override
    pubic void swimming(){
        System.out.printlin("游泳1");
    }
});

使用场景一:为按钮添加事件监听器对象

使用场景二:使用comparator接口的匿名内部类实现对数组排序

Lambda

Lambda表达式只能简化函数式接口的匿名内部类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@FunctionalInterface // 声明函数式接口的注解 声明后只能写一个抽象方法
interface Swim{
    void swimming();
}

/*Swim s1 = new Swim(){
    @Override
    public void swimming(){
        System.out.println("学生游泳");
    }
};
*/
Swim s1 = () - > {
    System.out.println("学生游泳");
};


函数式接口:只有一个抽象方法的接口
@FunctionInterface声明函数式接口的注解

静态方法引用

类名::静态方法 使用场景:Lambda表达式只调用一个静态方法，并且”->”前后参数形式一致，就可以使用静态方法引用。

实例方法引用

对象名::实例方法 使用场景:如果某个Lambda表达式里只是通过对象名称调用一个实例方法，并且“->”前后参数的形式一致，就可以使用实例方法引用。

特定方法类型引用

特性类的名称::方法 使用场景:某个lambda表达式中只是调用一个特定类型的实例方法，并且前面参数列表中的第一个参数是作为方法的主调，后面的所有参数都是作为该实例方法的入参的，则此时可以使用特定类型的方法引用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Arrays.sort(names);
Arrays.sort(names,new Comparator<String>(){
    @Override
    public int compare(String o1,String o2){
        //o1 a1
        //o2 a2
        return o1.compareToIgnoreCase(o2);
    }
});
Arrays.sort(names,(o1,o2) -> o1.compareToIgnoreCase(o2));
//特定类型方法引用: 类型名称::方法名
Arrays.sort(names,String::compareToIgnoreCase);

System.out.printlin(Arrays.toString(names));

构造器引用

类名::new 使用场景:如果某个lambda表达式里只是在创建对象，并且“->”前后参数情况一致，就可以使用构造器引用。

String

创建对象封装字符串数据的方式

  • 直接使用双引号“…”(会存储到字符串常量池，并且相同内容的字符串只存储一份)
  • new String类，调用构造器初始化字符串对象(每new一次都会产生一个新的对象放到堆内存中)

说些什么吧！

valine