JavaSE

Wool Blue 发布于

最后更新于

数据类型

(一) 基本数据类型

1. 数值类型

  • 整数类

    • byte
    • short
    • int
    • long

  • 浮点类型

    • float
    • double

2. boolean类型

(二) 引用数据类型

1. 类

2. 接口

3.数组

类型转换

低—————————————————————>高
byte，short，char–>int–>long–>float–>double

  • 强制类型转换 高->低
  • 自动类型转换 低->高

变量

(一) 变量类型

  • 局部变量：必须声明和初始化值 只在方法内有效

    1
    2
    int i =10;
    System.out.println(i);

  • 实例变量：从属于对象，定义在方法外。如果不自行初始化，则为默认值0/Null ps：布尔值默认为flase

    1
    2
    3
    //变量类型 变量名字 = new Demo()
    Demo demo1  = new Demo();
    System.out.println(demo1.age);

  • 类变量：从属于类（静态）

    1
    2
    3
    4
    //类变量 static
    static double salary = 3000；
    //一般使用类名.变量
    Student.age

(二) 变量命名规范

  • 所有变量、方法、类名：见名知意
  • 类成员变量：首字母小写和驼峰原则：monthSalary除了第一个单词以外，后面的单词首字母大写
  • 局部变量：首字母小写和驼峰原则
  • 常量：大写字母和下划线：MAX_VALUE
  • 类名：首字母大写和驼峰原则：Man,GoodMan
  • 方法名：首字母小写和驼峰原则：run(),runRun()

常量

1
2
//修饰符 不存在先后顺序
static final double PI = 3.14;

基本运算符

1
2
3
4
5
6
7
8
//字符连接符 + ，
int a = 10;
int b = 20;
System.out.println(a+b+"");  //30
System.out.println(""+a+b);  //1020

//三元运算符 x？y:z
//如果x==true 结果为y，否则结果为z

包机制

1
2
3
4
//一般利用公司域名倒置作为包名
package pk1.pk2.pk3....;
//使用时用import导入
import package1.pk2.pk3....;

Doc文档

1
2
3
4
/**
 * @author Blue_wool
 * @version 11.012
 */

JAVA流程控制

(一) Scanner

1
2
3
4
5
6
7
8
9
10
11
12
Scanner scanner = new Scanner(System.in);
System.out.println("使用next()接收：");

//判断用户有没有输入
if (scanner.hasNext())
{
    //使用next方法接收
    String str = scanner.next();
    System.out.println("输出内容为:"+str);
}
//凡是属于io流的类使用完需要关掉，释放内存
scanner.close();

1.next:

  • 一定要读取到有效字符后才可以结束输入。
  • 对输入有效字符之前遇到的空白，next()方法会自动将其去掉。
  • 只有输人有效字符后才将其后面输入的空白作为分隔符或者结束符。
  • next()不能得到带有空格的字符串

2.nextLine：

  • 以Enter为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符
  • 可以获得空白。
1
2
3
4
5
6
7
8
9
Scanner scanner = new Scanner(System.in);
System.out.println("请用户输入：");

//使用next方法接收
String str = scanner.next();
System.out.println("输出内容为:"+str);

//凡是属于io流的类使用完需要关掉，释放内存
scanner.close();

3.Scanner进阶

1
2
3
4
5
6
7
8
9
10
11
12
Scanner scanner = new Scanner(System.in);  // atl+回车
double sum = 0;
double x;
int n = 0;

while (scanner.hasNextFloat()) //hasNextFloat 可判断下一个输入值是否为float类型
{
    x = scanner.nextFloat();  //获取下一个为float类型的值
    sum = sum+x;
    n++;
}
System.out.println("平均为："+sum/n);

(二) 顺序结构

(三) 循环结构

增强for循环

1
2
3
4
for (int i : arry)  //数组名.for
{
	System.out.println(i);
}

方法

  • java方法是语句的集合，它们在一起执行一个功能。
  • 方法是解决一类问题的步骤的有序组合
  • 方法包含于类或对象中
  • 方法在程序中被创建，在其他地方被引用
  • 非静态方法可以访问类中的静态方法
  • 静态方法只可调用静态方法 不可调用非静态方法

方法的重构：同一方法名，但是传递参数的类型 不相同

可变参数

1
public static void add(double...a)  //可以传入多种类型的参数

数组

1
2
3
4
5
6
7
8
//定义一个数组
//静态初始化：创建+赋值
int[] a = {1,2,3,4,5};

//动态初始化:包含默认初始化
int[] arry;
arry = new int[10]; //int[] array = new int[10];
arry[0] = 1；

冒泡排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//比较数组中相邻元素，并交换位置
//每一次比较，都会产生一个最大或者最小的数
//下一轮排序则可以少排一次
//一次循环，直至结束
public static int[] sort(int[] array)
{
    int temp = 0;
    for (int i = 0; i < array.length - 1; i++) {  //外层循环 产生i个最大或最小值
        for (int j = 0; j < array.length - 1 - i; j++) { //内层循环，已产生的最大或最小值不参与比较
            if (array[j+1]<array[j])
            {
                temp=array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
            }
        }
    }
    return array;
}

稀疏矩阵

“C:\Users\31849\Desktop\文档\学习笔记\JavaSE\稀疏矩阵-java实现.md”

类与对象

对象的创建与使用

  • 必须使用new 关键字创建对象，构造器 Person Mike = new Person()
  • 对象的属性 ： Mike.age
  • 对象的方法： Mike.sleep()

构造器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//1.构造器与类名相同，没有返回值 （快捷键：alt+insert）
//2.使用new关键字，本质还是在调用构造器
//3.用来初始化值
public class Person {
    String name;
    int age;

    //无参构造
    public Person() {
    }

    //有参构造：一旦定义了有参构造，无参就必须显示定义
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
/*
    
    public static void main(String[] args) {
        Person Mike = new Person();  // 无参调用
        Person Jon = new Person(Jon,12); //有参调用
    }
 */

封装

  • 属性私有 get/set (快捷键alt+insert)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Person {
    private String name;  //属性一般为私有
    private int age;

    public String getName() {  //外部通过调用get/set方法获取类属性
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
/*
    Person s1 = new Person();
    s1.setName("张三");
    System.out.println(s1.getName());

 */

继承

  • pubic
  • private
  • protected
  • default
1
2
3
4
5
6
//子类会继承父类的所有的方法和属性(public),一般父类属性为私有 
//快捷键Ctrl+h
public class Student extends Person{

}

Super
  • super调用父类的构造方法，必须在构造方法的第一个
  • super必须只能出现在子类的方法或者构造方法中！
  • super和this不能同时调用构造方法！
  • 父类没有无参构造器，子类也无法进行无参构造
重写
  • 需要有继承关系，子类重写父类的方法
  • 方法名必须相同
  • 参数的列表必须相同
  • 修饰符：可以扩大，但是不能缩小。public>protected>Default>private
  • 抛出的异常：范围可以被缩小，但是不能扩大；ClassNotFoundException –> Exception
1
2
3
4
5
6
7
8
9
10
11
12
public class Person {
    public void say(){  //父类方法
        System.out.println("Person->say");
    }
}
/*
public class Teacher extends Person{ 
    @Override //注解：有功能的注释
    public void say() { //子类重写方法
        System.out.println("Teacher->say");
    }
}

多态

  • 同一个方法可以根据发送的对象(父/子)的不同采用多中不同的行为方式
  • 多态是方法的多态，属性没有多态
  • **父类和子类，需要有联系 ，注意类型转换异常 **
    • stastic：静态方法，属于类，不属于实例
    • final：常量，无法改变，重写
    • private：私有方法
  • 存在条件：继承关系，方法需要重写，父类引用指向子类对象； Father f1 = new Son();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//能调用哪些方法看左边，能执行哪些方法看右边
public static void main(String[] args) {

    //一个对象的实际类型是确定的
    //new Student()
    //new Person()
    //可以指向的引用类型不确定：父类的引用指向子类

    //Student 子类能调用的方法是自己的以及继承的父类的
    Student s1 = new Student();

    //Person 父类能调用的方法是自己的以及子类重写的，但是不能调用子类特有的
    Person s2 = new Student();
    Object s3 = new Student();

    s1.say();
    s2.say();//子类重写了父类的方法，执行子类的方法
    Student
}
instance of
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/*
以左边类名为准，判断A与B是否是父子或子父关系，如果是则编译通过，否则编译报错
编译通过后，再判断A是否是B的实例对象或B子类的实例对象
注意：A的实际类型不能是B的父类，不然就会是false
*/
Person s2 = new Student();
System.out.println(s2 instanceof Student);//ture
System.out.println(s2 instanceof Person);//true
System.out.println(s2 instanceof Object);//true
System.out.println(s2 instanceof Teacher);//false
System.out.println(s2 instanceof String);//编译报错

((Student)s2).eat(); //父类如果想用子类特有方法，需要转换类型，父亲装儿子
//子类转换为父类可能会丢失自己特有的方法
/*

static关键字

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Person {
    //2：赋初值
    {
        //代码块（匿名代码块）在构造器之前
    }
    //1：只执行一次
    static {
        //静态代码块
    }
    //3
    public Person() {
        //构造方法
    }
}

抽象类

  • 继承了抽象类的所有方法（包括抽象方法）的子类，必须实现它的方法，除非子类也是抽象类
  • 不可以new这个抽象类，只能通过子类来实现
  • 抽象方法必须定义在抽象类中
  • 抽象类中可以写普通方法
  • 抽象类例如模板，子类继承后，需要自己实例化
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public abstract class Person {
    public abstract void something();
}
/*
public class Student extends Person { //重写抽象父类方法
    @Override
    public void something() {
    }
}

public abstract class Student extends Person {  //子类为抽象类 
    
}
*/

接口

  • 接口就是多个类的公共规范
  • 接口是一种引用数据类型，最重要的内容就是其中的：抽象方法
1
2
3
4
5
6
7
8
/*
新建interface接口类型文件
定义抽象方法：public abstract 返回值类型 方法名称（参数列表）；
*/
public interface 接口名称{
	public abstract int methodAbs1();//抽象方法 public和abstract 可写可不写
    int methodAbs2();
}

接口的实现

1
2
3
4
5
6
7
8
9
10
/*
接口不能直接使用，必须得用一个实现类来实现（重写）接口里面的抽象方法,只能创建实现类的对象来使用，不可直接实例化接口
实现类在实现接口时，atl＋回车 只会重写abstract类型的方法
格式：
public class 实现类名称 implement 接口名称{
    //...
}
如果实现类没有覆盖重写接口的所有抽象类方法，则该实现类自己必须为抽象类
*/
demo1AbstractImpl abs1 = new demo1AbstractImpl(); //创建实现类的对象使用接口

接口的默认方法

1
2
3
4
5
6
7
8
9
/*
接口的默认方法：为了解决接口的升级问题，例如已有的接口已投入使用，但想新添加接口，但不影响原接口的使用
1.可以通过接口实现类对象，直接调用
2.也可以被接口实现类重写 
*/
//定义在接口中
public default 返回值类型 默认方法名称(){
    //方法体
}

接口中的静态方法

  • 不能通过实现类对象来调用接口中的静态方法
  • 只能通过接口名.静态方法名（参数）来调用

接口中的私有方法

1
2
3
4
5
6
7
8
9
10
//提取出接口中默认方法的公共部分
private void common(){
    System.out.println("abc");
    System.out.println("def");
}
//提取出接口中静态方法的公共部分
private static void common(){
    System.out.println("abc");
    System.out.println("def");
}

接口中的成员变量

  • 必须由public static final 修饰 （可以省略）
  • 必须进行赋值
  • 名称应为大写字母
1
public static final int NUM = 10;

接口实现注意事项

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/*
使用接口的时候，需要注意：
1.接口是没有静态代码块或者构造方法的。
2.一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。
格式：
public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB{

}
//覆盖重写所有抽象方法
3.如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
4.如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。
5.如果实现类锁实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。
6.一个类如果调用父类当中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法。
*/

接口的多继承

1
2
3
4
5
6
7
8
/*
1.类与类之间是单继承的。直接父类只有一个。
2.类与接口之间是多实现的。一个类可以实现多个接口。
3.接口与接口之间是多继承的。
注意事项
1。多个父接口当中的抽象方法如果重复，没关系。
2.多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，【而且带着default关键字】。
*/

内部类

成员内部类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Person {//外部类
    public void doing(){
        System.out.println("我是外部类方法");
    }
    public class Inner{ //内部类
        public void in(){
        System.out.println("我是内部类方法");
        Person.this.doing(); //内部类方法中 外部类名.this.外部类方法名 即可直接调用外部类方法
    }
    }
 }
Person person = new Person();
//通过外部类来实例化内部类
Inner inner = person.new Inner();
//也可以直接实例化
Person.Inner p  = new Person().new Inner();
/*
内部类可以调用外部类的私有属性和方法
*/

匿名内部类

  • 直接在方法中使用匿名内部类，将抽象方法实例化，获得实例对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public abstract class Student{ //定义一个抽象类

    public abstract void test(); //定义一个抽象方法

    public static void main(String[] args) {
        Student student1 = new Student() { //匿名内部类实现，并创建实例对象，其本身相当于一个相对应类型的子类
            @Override
            public void test() {
                System.out.println("我是匿名内部类");
            }
        };
//        StudentInterface student3 = new StudentInterface() { 接口的匿名实现
//            @Override
//            public void study() {
//                System.out.println("我是接口的匿名实现类");
//            }
//        };

lambda 表达式

  • 接口内部仅有一个待实现的抽象方法（不包括默认方法）
  • 仅能传入隐式变量（不改变的变量，final关键字）
1
2
StudentInterface student3 = (返回值) -> {方法体} //当返回值仅一个可以省略括号，方法体中仅一条语句，也可不写{}
//当一个方法需要接口的实现时，也可以调用lambda表达式

方法引用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
StudentInterface student = (a,b) -> a + b;//lambda表达式实现接口
StudentInterface student2 = Integer::sum; //直接使用integer定义好的求和方法实现接口
//如果为普通成员方法，同样需要使用对象来进行方法引用
//符合接口中方法的定义的 都可以直接进行方法引用
Student2 student2 = new Student2(); //Studnet2为普通类 其中test方法与接口中study方法一致 所以可以用方法引用
StudentInterface student = student2::test;
/*
public class Student2{
    public int test(int a,int b){
        return 0;
    }
    
public interface StudentInterface {  //接口
    int study(int a ,int b);
}
 */

异常

  • throws关键字
1
2
3
4
5
6
7
8
9
10
private static int test1(int a,int b){
    if (b==0)
        throw new ArithmeticException("除数不能为0"); //通过new出异常对象来使用，抛出运行时异常
    return a/b;
}
//当抛出非运行异常时，需要告知函数的调用会抛出哪些异常，并且当不同分支出现不同的异常时，需要在方法定义时明确指出会抛出的所有异常（添加到方法签名）
private static void test2() throws Exception{ //扔给上一级
    throw new Exception("我是编译时异常！");
}
//对父类重写时，只要重写的方法中不会抛出对应异常，就可不写

捕获异常

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//使用try - catch语句捕获异常
try { //监视区域
    test1(10,0);
}catch (ArithmeticException e){  //异常类型必须与方法中出现的异常类型一致或者是其父类如上
    System.out.println("捕获到异常");
}
System.out.println("程序正常运行");
}
//多重捕获
try { //必须异常机制的子类顺序在前
    test1(10,0);
}catch (ArithmeticException e){
    System.out.println("捕获到数学运算异常");
}catch (RuntimeException e){
    System.out.println("捕获到运行异常");
}catch (Exception e){
    System.out.println("捕获到异常");
}finally {
    System.out.println("捕获完毕"); //无论是否捕获成功，都会运行
}

泛型类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Fan<T，U....> { //当某个或某些值不确定类型时，可以定义为范类 默认为object类
    String name;
    int age;
    T value;
    U ability;
    public Fan(String name, int age, T value {//有参构造
        this.name = name;
        this.age = age;
        this.value = value;
    }
    public T getValue()  // T为返回值类型
    {
        return value;
    }
}
Fan<String> stringFan = new Fan<>("张三", 6, "优秀"); // 实例化时规定不定值的类型，可用<?>来表示任意类型
//注意：必须在类中使用泛类变量，静态内容中也不可用
//形参T不能直接实例化例如new T()
//具体类型不同的泛型变量，不能使用不同的变量来接收
//泛类只是引用类型，不支持基本类如int，double等需使用其包装类，但是基本类型的数组可以<int []>
Wool Blue

Wool Blue

学习新思想，争做好青年

21
2
6
TOC
  1. 1. 数据类型
    1. 1.1. (一) 基本数据类型
    2. 1.2. (二) 引用数据类型
  2. 2. 类型转换
  3. 3. 变量
    1. 3.1. (一) 变量类型
    2. 3.2. (二) 变量命名规范
  4. 4. 常量
  5. 5. 基本运算符
  6. 6. 包机制
  7. 7. Doc文档
  8. 8. JAVA流程控制
    1. 8.1. (一) Scanner
    2. 8.2. (二) 顺序结构
    3. 8.3. (三) 循环结构
  9. 9. 方法
  10. 10. 数组
  11. 11. 类与对象
    1. 11.1. 抽象类
    2. 11.2. 接口
    3. 11.3. 内部类
    4. 11.4. 异常
    5. 11.5. 泛型类
CATEGORYS
TAGS
Hadoop Python 前端 数据库 数据结构 机器学习