java学习笔记

类型转换

低到高类型

Byte, short, char, int, long, float, double

//强制转换  （类型）变量名 高--低
int i=128;
byte b=(byte)i; //加了扩号为强制转换，此处内存溢出 
//自动转换 低--高
double b=i;

注意点：

1 不能对布尔值转换

2 不能把对象类型转换为不相干的类型

3 在把高–低时候强制转换

4 转换时候可能存在内存溢出或者精度问题

System.out.println((int)23.7);//23
System.out.println((int)-45.89f);//-45
char c='a';
int d=c+1;  //低转高 自动
System.out.println(d);  //98
System.out.println((char)d); //b

操作比较大的时候注意溢出问题

新特性：数字之间可以用下划线分割

int money=10_0000_0000;
int year=20;
int total=money*year; //结果溢出
long total2=monry*years; //默认是int乘完再变成long，因此转换之前就已经存在问题了。
long total3=money*((long)year); //可以

用大写的L，因为小写的l像①

变量

局部变量

public static void main(String[] args){
    int i=10; //局部变量
}

实例变量

默认值

布尔值默认false

除了基本类型，其余默认值都是null

public clss Demo08{
    //实例变量：从属于对象
    String name;
    int age;
public static void main(String[] args){
   //变量类型 变量名字=new Demo08()
    Demo08 demo08=new Demo08();
 }
}

类变量

public clss Demo08{
    static double salary =2500;
}

变量命名规范

类成员变量：首字母小写和驼峰原则：monrhSalary

局部变量：首字母小写和驼峰原则

常量：大写字母和下划线

类名：首字母大写和驼峰原则

方法名：首字母小写和驼峰原则： run(), runRun()

常量

// final 常量名=值；
//常量名一般使用大写字符
//修饰符不存在先后顺序
static final double p=1;
final static double p=1;

运算

运算符

取余 %

关系运算符 instanceof

位运算符：^ 非 （异或 相同为0不同为1 ）

条件运算符 ？ ：

x ? y :z //如果x==true，则结果为y，否则结果为z
String type =score<60 ? "不及格":"及格"; //必须掌握，开发中十分常见。比if更加精简

z = x>y ? x-y : x+y;
2<<3 = 16; // <<左移  指向哪边往哪边移 0000 0001 -> 0001 0000
// << *2 >> /2

数学 Math. 往下找相关操作

幂运算 pow（2，3） //2的三次方 效率高

运算类型

如果有long 则返回long，

如果有double 返回double

如果没有long则返回int （默认）

快捷键

crtl+d ：复制当前行到下一行

包机制

包的本质就是文件夹

一般利用公司域名倒置作为包名： www.baidu.com 的包 -》com.baidu.www

不要让包之间的名字重复

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

import package1[.package2...].(classname|*);// 导入包 
import com.base.*; //.*为通配符将包下所有内容导入

《阿里巴巴开发手册》

JavaDoc

javadoc命令生成自己的API文档

/**
*@author xxx
*@since 1.8
*/

学会查找使用IDEA生产javddoc文档

Scanner

输入 基本语法：

Scanner s= new Scanner(System.in);

ublic class demo01 {

    public static void main(String[] args) {
       Scanner scanner= new Scanner(System.in);

       /* System.out.println("使用next方式接收");
        if(scanner.hasNext()){
            String str=scanner.next();
            System.out.println("输出的内容为："+str);
        }*/

        System.out.println("使用nextLine方式接收");
        if(scanner.hasNextLine()){
            String str=scanner.nextLine();
            System.out.println("输出的内容为："+str);
        }
        //IO流的类不关闭会一直占用资源
        scanner.close();
    }
}

通过使用 next() 或 nextLine() 来接收数据 nextLine下一行

next():

1 一定要读取到有效字符后才可以结束

2 有效字符前有空白，next()方法会自动将其去掉

3 只有输入有效字符后才将后面的空白作为分隔符or结束符

4 next()不能得到带有空格的字符串

nextLine():

1 以Enter为结束符

2 可以获得空白

public class Demo04 {
    public static void main(String[] args) {
        Scanner scanner =new Scanner(System.in);
        int i=0;
        float f=0.0f;

        System.out.println("请输入整数");
        
        if(scanner.hasNextInt()){
            i=scanner.nextInt();
            System.out.println("整数数据："+i);
        }else {
            System.out.println("不是整数数据");
        }

        System.out.println("请输入小数");
        if(scanner.hasNextFloat()){
            f=scanner.nextFloat();
            System.out.println("小数数据："+f);
        }else {
            System.out.println("不是整数数据");
        }

        scanner.close();
    }
}

增强for循环

int[] numbers={10,20,30,40,50};
//遍历数组元素
for(int x:numbers){
    System.out.println(x);
}
//输出 
10
20
30
40
50

方法

类似函数

方法在程序中被创建，在其他地方被引用

修饰符 返回值类型 方法名（参数类型 参数名）{

…

方法体 …

return 方法值

}

如果方法返回值是void，方法调用一定是一条语句。

方法重载

！！方法名必须相同

！！参数列表必须不同（个数不同 or类型不同 or参数排列顺序不同）

！方法返回类型可以相同可以不同

！仅仅返回类型不同不足以成为方法的重载

命令行传参（较少见）

编译的时候可以不用包名，运行的时候需要写包名 把路径找对

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

//在cmd里   java com.xxx.xxx i am student
//结果：
args[0]:i
args[1]:am
args[2]:student

可变参数

在指定参数类型后加一个省略号 …

一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。

public static void main(String[] args){
    Demo4 demo4=new Demo4();
    demo4.test(1,2);
}

public void test(int...i){
    System.out.println(i[0]);
    System.out.println(i[40]);
}

数组m

两种写法：

int[] nums;  //1定义 首选方法
int nums2[]; //为了让c用户适应m
int[] nums=new int[10];

面向对象编程 OOP（Object-Oriented Programming)

分类的思维模式

面向对象本质：以类的方式组织代码，以对象的组织（封装）数据

三大特性

封装 把数据包装起来，对外提供小口访问

继承

多态

先有对象后有类。对象是具体的事物，类是对对象的抽象。

eg 人是对象 老师是抽象的

静态方法

静态方法可以直接调用

static和类一起加载的

非静态方法

静态不能直接调用非静态方法要实例化这个类 new ；实例化之后才存在

一个类只有一个 public class 可以有多个class

类

属性：字段

string name;

int age;

方法

public void study(){

sout(this.name+“在学习”);

}

类实例化后会返回一个自己的对象

Student xiaoming= new Student();

构造器

一个类什么都不写也会存在一个方法

1 和类名相同

2 没有返回值

作用

使用new关键字，必须要有构造器

实例化初始值

注意点:

1 定义有参构造之后，如果想用无参构造，显示的定义一个无参的构造

//无参
public Person(){
}

//有参
public Person(String name){
    this.name=xxx;
}

快捷键

alt+insert 选Constructor ok有参 Select None 无参

idea打开class文件

project structure->Modules->加out目录

封装

高内聚，低耦合

高内聚：类的内聚数据操作细节自己完成。

低耦合：仅暴露少量的方法给外部使用。

属性私有 , get/set

private String name;

可操作这个属性的方法

//get  获得这个数据
public class Student{
    private String name;
public String getName(){
    return this.name;
 }
}

//在psvm里
Student s1=new Student();
s1.getName();

//set 设置数据
public void setName(String name){
    this.name=name;
}

//在psvm里
Student s1=new Student();
s1.setName("小明");

快捷键

alt+insert -> Getter and Setter

接口

public interface 接口名称{
    //内容
}

接口包含内容

1 常量

2 抽象方法

（以下java8有）

3 默认方法

4 静态方法

（以下java9有）

5 私有方法

修饰符

接口中的抽象方法，修饰符必须是两个固定的关键字： public abstract (可选择性忽略)

public interface My{
    //这是一个抽象方法
    public abstract void method();
    
        //这是一个抽象方法
    abstract void method();
    
        //这是一个抽象方法
    public void method();
    
        //这是一个抽象方法
    void method();
}

super

private String name="qingjiang";

public void test(String name){
    sout(name);  //传递进来的name
    sout(this.name);   //类里面的name 即qingjiang
    sout(super.name);  //父类里面的name
}

私有的方法无法被继承

public Student(){
super(); //隐藏代码，调用了父类的无参构造，必须要在子类第一行执行
sout(student 无参执行)
}

注意点：

1 super调用父类的构造方法，必须在构造方法第一个

2 super必须只能出现在子类的方法或构造方法中

3 super和this 不能同时调用构造方法。

Vs this

​ 代表的对象不同

​ this：本身调用这个对象

​ super：代表父类对象的应用

​ 前提

​ this：没有继承也可以使用

​ super：只能在继承条件才可以使用

​ 构造方法

​ this（）； 本类的构造

​ super（）； 父类的构造

接口使用

public class 实现类名称 implement 接口名称{
    // ...
}

2 接口的实现必须覆盖重写接口中所有的抽象方法

实现：去掉abstract关键字 加上方法体大括号

3 创建实现类的对象进行使用。

不能直接 new接口

创建实现类的对象使用

注意：如果实现类没有覆盖所有方法，那么这个实现类自己就必须是抽象类

Static

顺序：

静态（只执行一次）

匿名

构造器

被final定义不能被继承

抽象

抽象方法只有方法的名字，没有方法的实现

抽象类的所有方法必须由子类实现

接口可以多继承

1.不能new抽象类，只能靠子类去约束

2.抽象类中可以写普通方法

3.抽象方法必须在抽象类中

匿名

异常

检查性异常

运行时异常

捕获多个异常 ：从小到大

快捷键： crtl+alt+t

throw 主动抛出异常，一般在方法中使用

throws 假设这个方法中处理不了这个异常，方法中抛出异常