Java基础学习笔记（狂神说Java）
Java基础
注释
单行//，多行/* 注释 /
文档注释
/*
*@Description
*@Author
*/
标识符
数据类型
long num = 30L;
float num = 10.1F;
最好完全避免用浮点数进行比较 （用Bigdecimal）
强制类型转换（不能对boolean转换）：(类型)变量名
数字可以用下划线区分，且不会被输出。
变量
类变量（static），实例变量，局部变量（方法内）
常量（final，不存在先后顺序）
驼峰原则（monthSalary）
类名首字母大写
包机制
一般用公司域名倒置作为包名
JavaDoc生成文档
package com.A1oe;
/**
* @author A1oe
* @version 1.0
*/
public class Hello {
/**
* @param args
*/
public static void main(String[] args){
System.out.println("com.A1oe.Hello World");
}
}
cmd: javadoc -encoding UTF-8 -charset UTF-8 Hello.java
IDEA: Tools - Generate JavaDoc
交互Scanner对象
package com.A1oe;
import java.util.Scanner;
public class Hello {
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()){ //hasNextLine(), hasNextInt(),hasNextFloat()等
String str = scanner.next();
System.out.println(str);
}
// 凡是IO流都要关掉
scanner.close();
}
}
增强for循环
package com.A1oe;
public class Hello {
public static void main(String[] args){
int[] nums = {1,2,3,4,5};
for (int x: nums){
System.out.println(x);
}
}
}
方法
修饰符 返回值类型 方法名(参数类型 参数名){
方法体
return x;
}
方法重载：方法名字相同，参数类型/个数/顺序不同
命令行传参
package com.A1oe;
public class Hello {
public static void main(String args[]){
for (int i=0; i<args.length; i++){
System.out.println(args[i]);
}
}
}
cmd: java com.A1oe.Hello hello world
可变参数
一个方法中只能指定一个可变参数，必须是方法的最后一个参数
package com.A1oe;
public class Hello {
public static void main(String[] args){
System.out.println("Hello World");
}
public static void PrintMax(double... nums){
if (nums.length == 0){
return;
}
double result = nums[0];
}
}
数组
//声明
dataType[] arrRefVar;
//new操作符创建数组
dataType[] arrayRefVar = new dataType[arraySize];
//数组长度
array.length
初始化
//静态
int[] a = {1,2,3};
//动态
int[] a = new int[2];
a[0]=1;
a[1]=2;
//默认初始化
-
数组长度是确定的，大小不可以改变
-
元素类型相同
多维数组
int a[][] = new int[2][5];
Arrays类
package com.A1oe;
import java.util.Arrays;
public class Hello {
public static void main(String[] args){
int[] a = {1,2,3};
Arrays.sort(a); //fill, equals, binarySearch
System.out.println(Arrays.toString(a));
}
}
稀疏数组
构造器
-
必须和类名相同
-
必须没有返回值，也不能是void
package com.A1oe;
public class Hello {
String name;
public Hello() {
this.name = "a";
}
}
IDEA: alt+insert 生成构造器
封装
-
高内聚，低耦合；内部数据操作细节自己完成，尽量暴露更少的 方法
-
属性私有，get/set（public）
-
提高安全性，保护数据
-
隐藏实现细节
-
统一接口
-
增加系统可维护性
继承
-
extends，子类是父类的扩展
-
public全部继承，private无法继承；public>protected>default>private
-
所有类默认直接/继承继承Object类
-
只能单继承
IDEA：Ctrl+H打开继承树
- super访问父类（private无法被继承）
重写
-
方法的重写，非private
-
需要有继承关系
-
方法名相同，参数列表相同，修饰符范围可以扩大(private->public)
-
抛出异常可以缩小，不能扩大（ClassNotFoundException->Exception）
-
IDEA：alt+insert
//A
package com.A1oe;
public class A extends B{
public static void test(){
System.out.println("A");
}
}
//B
package com.A1oe;
public class B{
public static void test(){
System.out.println("B");
}
}
//Hello
package com.A1oe;
public class Hello{
public static void main(String[] args) {
A a = new A();
a.test(); //A
B b = new A();
b.test(); //B
}
}
//A
package com.A1oe;
public class A extends B{
public void test(){
@Override
System.out.println("A");
}
}
//B
package com.A1oe;
public class B{
public void test(){
System.out.println("B");
}
}
//Hello
package com.A1oe;
public class Hello{
public static void main(String[] args) {
A a = new A();
a.test(); //A
B b = new A(); //子类重写父类方法，非静态
b.test(); //A
}
}
多态
//A
package com.A1oe;
public class A extends B{
@Override
public void test(){
System.out.println("A");
}
public void test1(){
System.out.println("A");
}
}
//B
package com.A1oe;
public class B{
public void test(){
System.out.println("B");
}
}
//Hello
package com.A1oe;
public class Hello{
public static void main(String[] args) {
A a = new A();
// B父类，可以指向子类，但是不能调用子类独有的方法
B b = new A();
//((A) b).test1(); //强制转换才能调用
Object c = new A();
}
}
-
多态：同一方法可以根据发送对象的不同而采用多种不同的行为方式
-
对象能执行哪些方法，主要看对象左边的类型
-
属性没有多态
-
static、final、private无法使用
instanceof
-
判断一个对象时什么类型
-
Object->B->C，在这条线上用instanceof都是true，因为有父子关系
static
package com.A1oe;
public class Hello{
static { // 只执行一次
// 1静态代码块
}
{ //赋初始值
//2匿名代码块
}
//3构造方法
}
静态导入包
package com.A1oe;
import static java.lang.Math.random
public class Hello{
public static void main(String[] args) {
System.out.println(random());
}
}
抽象类
-
abstract 抽象，public abstract class A{}
-
抽象方法，只有名字没有实现，public void action() {}，继承的子类必须实现。如果有抽象方法，必须时抽象类
-
不能new抽象类，只能靠子类实现
-
抽象类存在构造器，提高开发效率
接口
-
interface，只有规范，无法写方法，专业的约束，约束和实现分离
-
接口方法默认是public abstract，可以不写
-
接口定义变量public static final
-
可以实现多个接口
package com.A1oe;
public interface Hello{
void add(String name);
void delete(String name);
}
//实现
public class UserServiceImpl implements Hello{
}
内部类
-
类中还有类，通过外部类实例化内部类
-
成员内部类能操作外部类私有属性、方法；静态内部类不能（除非也是static，初始化顺序相关概念理解下就行）；
-
一个java文件中可以有多个class，但是只能有一个public
-
局部内部类：方法中的类。匿名内部类：new了，但是没有名字
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner() ;
异常
-
try，catch，finally，throw，throws
-
IDEA：ctrl+alt+t，自动生成ifelse，trycatch等
-
throw主动抛出异常，一般在方法中使用
-
方法上使用throws
package com.A1oe;
public class Hello{
public static void main(String[] args) {
try {
}catch (Exception e){ //从小到大
e.printStackTrace();
}catch (Throwable t){
}
finally {
}
}
}
