欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

JAVA SE 学习笔记

程序员文章站 2022-06-09 21:37:51
...
  • Java中不同进制的表现形式

    • 二进制:由0-1组成,以0b开头—>0b100
    • 八进制:由0-7组成,以0开头—>0100
    • 十进制:由0-9组成,整数形式—>100
    • 十六进制:由0-9a-f组成,以0x开头—>0x100
  • 原码,反码,补码(计算机都是以补码进行运算)

    • 原码:符号位+二进制定点,符号位0表示正,1表示负
    • 反码:正数的反码和其原码相同,负数的反码是对其原码逐位取反,符号位不变
    • 补码:正数的补码和其原码相同,负数的补码是在其反码的末位+1
    • eg:原码:1 0000111,反码:1 1111000,补码:1 1111001
  • 数据类型

    • 整数型
      • byte : 一字节 -128~127
      • short : 两字节 -215~215-1
      • int : 四字节,默认
      • long : 八字节,赋值要在数值末尾+L,如:888888888L
    • 浮点型
      • float : 四字节,赋值要在数值末尾+F,如:12.3F
      • double : 八字节,默认
    • 字符型
      • char : 两字节,单个字符用单引号,多个用双引号
      • String : 字符串类型
    • 布尔型
      • boolean
  • 数据类型转换

    • 隐式转换
    int x = 100;
    byte y = 100;
    x = x + y;            //这里y发生了隐式转换
    
    • 强制转换
    int y = 100;
    byte x = 100;
    x = (byte)(x + y);    //这里x发生了强制转换
    
    • 数据类型大小关系
      • byte,sort,char–int–long–float–double
      • 如果运算中出现了跨大小类型,会先转化为大的在做运算
  • 变量运算和常量运算

    byte a = 3;
    byte b = 4;
    byte c = a + b;      //这里会报错.1:运算的时候都会转为默认int类型运算;2:a,b是两个变量,变量的值在编译的时候无法确定
    byte d = 3 + 4;     //这里不会报错,可以理解为赋值,因为都是常量运算
    byte e = a + 4;      //这里会报错,理由同上
    
  • 字符和字符串的运算

    • 字符运算(以ASCII码运算)
    System.out.println('a');               //-->a;
    System.out.println((char)('a'+1));     //-->b;
    System.out.println('a'+1);             //-->98;转化为ASCII码
    System.out.println('a'+'a');	           //-->194
    
    • 字符串运算(注意先后顺序)
    System.out.println(1+'a'+"bc");     //-->98bc
    System.out.println("bc"+1+'a');     //-->bc1a
    System.out.println("5+5="+5+5);     //-->5+5=55
    

  • 运算符

  • 算术运算符

    • ‘/’ : 取整; ‘%’ : 取余; ‘++’ : 自增; ‘–’ : 自减
    • 注意运算中 ++a 和 a++ 的区别
    • eg : a = 1 ; b = (a++) + (++a) = 1 + 3 = 4
  • 赋值运算符

    • = ; += ; -= ; *= ;
  • 比较运算符

    • == , != ,… 返回的是bool类型(True,False)
  • 逻辑运算符

    • & , | , ! , ^ (亦或,01为True,11和00都为False)
    • && 短路与,如果左边是False时则不再继续执行右边,返回结果和&一样,如 (++a) && (++b),后面++b不会执行
    • eg x < 15 & x > 5 (和python(5<x<15)不一样)
  • 位运算符(操作对象是二进制)

    • & : 位与,有0则0 —> 6 & 2 结果是2
    • | : 位或,有1则1
    • ^ : 位亦或,相同0,不相同1,一个数对另一个数位异或2次,该数不变 —> 5 ^ 10 ^ 10 结果为5,
    • ~ : 取反,按位取反 —> ~6 结果是-7(补码思考)
    • 位移运算符
      • << : 左移,左边最高位丢弃,右边补0,向左移几位相当于乘上2的几次幂. —>12 >> 2 = 12*2^2 = 48
      • >> : 右移,最高位是0左边补0,1补1. 向右移几位相当于除以2的几次幂. —>12 >> 2 = 12/2^2 = 3
      • >>> : 无符号右移,无论最高位是0还是1,左边补0
  • 三目(元)运算符

    • (关系表达式) ? 表达式1(if True) : 表达式2(if False);
    • eg : z = (x > y) ? x : y; —>比较大小
    int a = 8;
    int b = 9;
    int c = 20;
    int x = (c > ((a > b)? a : b)) ? c : ((a > b)? a : b);      //找出三个数中最大的数
    System.out.println(x);
    
  • 键盘录入(类似python中的input)

	import java.util.Scanner;                             //导入库
	
	class test1 {
		public static void main(String[] args) {
			System.out.println("请输入一个整数:");
			Scanner sc = new Scanner(System.in);          //创建一个键盘输入对象sc
			int x = sc.nextInt();                         //使用对象的输入方法
			System.out.println("你输入的整数是:  " + x);
		}
	}           //整体等价于python中的 x = input('请输入一个整数:')

  • 流程控制语句

  • 顺序结构

    • 从上往下,依次执行,和python一样
  • 选择结构

    • if语句(三种格式)
    //=============格式1=============
    if (1 > 2) {
    	System.out.println("这是格式1");
    }
    //=============格式2=============
    if (2 > 2) {
    	System.out.println("True");		
    }else {
    	System.out.println("False");
    }
    //=============格式3=============
    if (2 > 2) {              //如果是True则执行"1True"后结束,如果是False则执行下个else if
    	System.out.println("1True");		
    }else if (3 > 2) {
    	System.out.println("2True");
    }else (){
    	System.out.println("False");
    }
    
    • switch语句
    String name = "张三";
    String gender = "男士";
    switch (gender) {
    case "女士":
    	System.out.println(name+"是一位"+gender+"喜欢买包包.");
    break;
    case "男士":
    	System.out.println(name+"是一位"+gender+"喜欢踢足球.");
    break;
    default :
    	System.out.println(name+"啥也不是.");
    break;
    }
    
  • 循环结构

    • for
    for (int i=1 ; i<=10 ; i++ ) {
    	System.out.println("正在打印第"+i+"次");
    }
    
    • while
    int num = 10;
    while (num > 0) {
    	System.out.println(num);
    	num--;
    }
    
    • do while 用于至少执行一次循环体的场景
    • for和while的区别 : for在执行完之后,控制变量内存会释放,while不会,还会一直保留.
  • 控制跳转语句

    • break : 只能在switch语句和循环语句中
    • continue : 只能在循环语句中,表示跳出本次循环,继续下次循环
    • return : 不是用于结束循环,而是结束方法
    • 控制跳转语句标号,用于嵌套循环中指定结束循环
    a : for (int i =1 ; i<=3 ; i++ ) {
    	System.out.println("i = " + i);
    	b : for (int j = 1 ; j<= 3 ; j++ ) {
    		System.out.println("j = " + j);
    		break a;
    	}
    } 
    

  • 方法

  • 概念:

//对应python中的def func():
修饰符 返回值类型 方法名(参数) {       //修饰符有public static ; 返回值类型 : void,char,int,sort....
	方法体语句;
	return 返回值;}
//===================例子===================
class Test{                              //创建了test类
	public static void main(String[] args) {       //python中main()方法
		System.out.println("Hello World!");
		Test obj1 = new Test();          //创建test类的对象obj1
		int r = obj1.sum(5,10);          //调用对象里面的sum方法;在python中: obj1 = test(5,10) ; r = obj1.sum() 
		int r = sum(5,10);               //自己类中直接调用就行
		boolean r = same(10,20);
		System.out.println(r);
	}
	public static int sum(int x,int y) {        //sum()方法,算出两数之和
		int z = x + y;
		return z;
	}
	public static int max(int x,int y) {        //max()方法,返回最大值
		if (x > y) {
			return x;
		}else {
			return y;
		}
	}
	public static boolean same(int x,int y) {   //same()方法,判断两数是否相等
		boolean z = (x == y);
		return z;
	}
}
  • 方法重载

    • 概念 : java中允许有同样的方法名,java会根据你传递的参数自动选择对应的方法
    • 重载的分类
      • 1 参数个数不同
      • 2 参数类型不同

  • 数组

  • 概念

    • 类似python的list,可以储存基本数据类型,也可以储存引用数据类型
    • 初始化 :
      • 动态初始化 : 只指定长度,由系统给出初始化值
      //动态初始化 : 数据类型[] 数组名 = new 数据类型[数组长度];
      int[] num = new num[20];                 //int数组默认值为0,即num[0] = 0,num[1] = 0 ....
      int[]][] num = new num[20][20];	         //二维数组
      
      • 静态初始化 : 给出初始化值,由系统决定长度
      //静态初始化 : 数据类型[] 数组名 = new 数据类型[]{元素};
      //简化写法 : int[] num = {元素}
      int[] num = new num[]{1,2,3,4,5};        //
      int[] num = {1,2,3,4,5};                 //简易写法,缺点是声明数组num的同时必须赋值
      int[][] num = {{1,2},{3,4},{5,6}};	     //二维数组
      
  • 内存的组成

    • 栈 : 储存局部变量,方法.先进后出
    • 堆 : new出来的数组或对象
    • 方法区 : 储存的代码先加载进内存(方法区),然后开始运行代码,其中会先自动运行main方法,这时main方法加载到栈里面,接着运行main方法的语句,如果遇到要执行其他类的代码,那么又会把该类代码加载进方法区,然后接着进栈继续运行
    • 本地方法区 : 和系统相关
    • 寄存器 : 给cpu使用
  • 数组的操作

    • 1 遍历
      • 使用for循环
      int[] arr = {1,2,3,4,5,6,7,8,9,10};           //数组赋值
      for (int i = 0 ;i < arr.length ;i++) {       //遍历数组
      	System.out.println(arr[i]);
      }```
      
    • 2 属性
      • arr.length 返回数组的长度
  • 二维数组

    • 二维数组不要求矩阵对齐
    int[][] arr = new int[3][];             //创建一个3行的二维数组,列暂时还没赋值,此时地址为null,即arr[0] = null
    int[0] arr = new int[2];                //第一行有2列
    int[1] arr = new int[3];	                //第二行有3列
    int[2] arr = new int[4];                //第三行有4列
    

  • 面向对象

  • 面向过程和面向对象的理解

    • 洗衣服例子…
  • 类与对象

    • java中最基本的单位就是类(class)
    • 成员变量(属性) : 在类中,方法外
    • 成员方法 : 和之前讲的方法一样,但是没有static这个修饰符
    • 对象就是类的实例化(如对象是张三,李四,王五,类是学生类)
  • 创建类的步骤

    • 定义修饰成员属性—>创建无参和有参构造—>创建私有成员属性的get,set方法—>创建其他成员方法
  • 创建对象与使用

class Student {                               //这里称为测试类,因为里面有main()方法,没有main()方法无法运行
	public static void main(String[] args) {
		Stu xiaoming = new Stu();             //创建对象格式: 类名 对象名 = new 类名();
		xiaoming.run();
	}
}
class Stu {                                   //创建一个人学生类Stu
	String name;                              //定义成员属性:学生姓名
	int age;                                  //定义成员属性:学生年龄
	String gender;                            //定义成员属性:学生性别
	public void run() {                       //定义成员方法:run()
		System.out.println("我在跑步");
	}
}
class Phone {                                 //创建一个人手机类Phone
	String brand;                             //定义成员属性:品牌
	int price;                                //定义成员属性:价格	
	public void call() {                      //定义成员方法:call()
		System.out.println("正在打电话");
	}
	
	public void message() {                   //定义成员方法:message()
		System.out.println("正在发短信");
	}
}
  • 成员变量和局部变量

    • 位置上不同:
      • 成员变量在类中的方法外
      • 局部变量在方法中或方法声明上
    • 内存位置不同:
      • 成员变量在堆内存(属于对象)
      • 局部变量在栈内存(属于方法)
    • 生命周期不同:
      • 成员变量随着对象消失而消失
      • 局部变量随方法结束而消失
    • 初始化值不同:
      • 成员变量有默认初始化值
      • 局部变量没有默认初始化值,必须先定义,赋值后才能使用
    • 注意事项:
      • 局部变量和成员变量名相同,在方法使用时,采用就近原则
      • 引用数据类型变量包括:数组,类,接口,枚举
  • 方法的形参是类的情况如何调用
class Student {
	public static void main(String[] args) {
		print(10);
		Phone s = new Phone();                      //创建s对象
		print(s);									//传入s地址,执行方法
	}
	public static void print(int x) {
		System.out.println(x);
	}
	public static void print(Phone x) {             //这里x可以理解为地址的形参
		x.name = "诺基亚";
		x.price = 5000;	
		x.run();
	}
}
class Phone {
	String name;
	int price;
	public void run() {
		System.out.println("他在使用"+price+"块钱的"+name);
	}	
}
  • 匿名对象

    • 很类似python中的lambda临时方法
    • 没有名字的对象,节省代码
    • 用完一次就不再用了
    • 匿名对象可以当做参数传递;例子: print(new Phone()); (用上面的demo)
    • 格式: new Phone().run(); (用上面的demo)’
  • 构造方法Constructor

    • 作用:给对象的属性做初始化.(就是python类中def init()方法)
    • 特点:方法名和类名相同,没有返回值(void也没有),没有返回值return
    • 构造方法也有重载,如:空参构造和有参构造
    class Student {
    	public static void main(String[] args) {
    		Phone s1 = new Phone("小明",1000); 
    		s1.run();  
    		Phone s2 = new Phone("大明",5000);
    		s2.run();
    	}
    }
    class Phone {
    	private String name;
    	private int price;                  
    	public Phone(String name,int price) {                   //有参构造.等价于python的def __init__(name,price)
    		this.name = name;
    		this.price = price;
    		System.out.println(name+"对象创建完毕!");
    	}
    	public Phone() {                                        //空参构造
    		System.out.println("这是一个空参构造");
    	}
    	public void run() {                        
    		System.out.println(name+"在使用"+price+"块钱的手机");
    	}	
    }
    

  • 继承

  • 概述:

    • 能提高代码的复用性和维护性,是多态的前提,弊端是让累的耦合性增强了
    • java只支持单继承,但可以使用多层继承(父子孙)
    • 子类能继承父类所有的非私有成员(属性,方法)
    • 子类不能继承父类的构造方法,但是可以通过super关键字去访问父类构造方法(和python中的继承一样 super(子类名称,self)._init_())
    • 不要因为部分功能而选择继承
  • 成员的关系

    • 属性
      • 如果出现子父类成员名属性相同时,按照就近原则(实际工作中不允许出现同名情况)
      • 如果真出现了,可以使用this(本类的调用)和super(父类的调用)关键字选择调用
    • 方法
      • 子类和父类有相同的方法:重写(既想用父类方法,又想新增子类新方法),重载
      • 如果是父类静态方法,子类也必须是静态方法才能重写(要不然系统无法识别该使用哪个方法)
      • 调用格式: super.父类方法名()
      class Test {
      	public static void main(String[] args) {
      		IOS8 user = new IOS8();
      		user.call();
      		user.siri();
      	}	
      }
      class IOS7 {
      	public void call() {
      		System.out.println("打电话");
      	}
      	public void siri() {
      		System.out.println("Speak English");
      	}
      }
      class IOS8 extends IOS7 {
      	public void siri() {
      		super.siri();                             //重写了siri()方法,即继承了父类,又新增(升级)了新的方法
      		System.out.println("Speak Chinese");      
      	}
      }
      
  • 构造方法在继承中的关系

    • 子类所有的构造方法都会访问父类中空参的构造方法(因为子类是继承使用父类数据的,所以子类在构造前要有父类的数据)
    • object类是最顶层的类(和python一样)
    • 如果父类没有空参构造,只有有参构造,就通过super(参数1,参数2…);传递使用
    class Test {
    	public static void main(String[] args) {
    		Son s = new Son("哈哈");
    	}
    }
    class Father {                              
    	String str;
    	Father(String str) { 
    		this.str = str;
    		System.out.println("父类空参构造=========="+str);
    	} 
    }
    class Son extends Father {             
    	int num;
    	Son(String str) {                                
    		super(str);                         //调用父类有参构造
    		System.out.println("子类空参构造");
    	}
    }
    

  • 多态

  • 概述:

    • 多态的前提: 1.有继承关系; 2.要有方法重写; 3.要有父类引用指向子类对象
    • 多态的好处: 1.提升代码的维护性; 2.提高了代码的拓展性
    • 多态的弊端: 不能使用子类特有的属性和方法
    • 多态中访问成员属性
      • 编译(是否会报错)看左边(父类),运行看左边
    • 多态中访问成员方法
      • 编译看左边,运行看右边(子类)(动态绑定),所以必须有方法重写
    • 多态中访问静态成员方法
      • 编译看左边,运行看左边
    • 向上转型和向下转型

    class Test {
    	public static void main(String[] args) {
    		IOS7 user = new IOS8();                //父类引用指向子类对象,也属于向上转型
    		user.siri();
           	IOS7 user_new = (IOS7)user;         //向下转型,能够使用子类独有的方法
    		user_new.call();
    	}	
    }
    class IOS7 {
    	public void siri() {
    		System.out.println("Speak English");
    	}
    }
    class IOS8 extends IOS7 {
    	public void siri() {
    		super.siri();                             
    		System.out.println("Speak Chinese");
    	}
    	public void call() {
    		System.out.println("打电话");
    	}
    }
    ==================================================
    打电话
    Speak English
    Speak Chinese
    

  • 修饰符

  • 非访问修饰符

    • static:

      • 静态修饰符,表该成员属性,方法是所有对象共享的,作用是避免内存的浪费
      • 随着类的加载而加载,且优先对象存在
      • 静态方法只能访问静态的成员变量和静态的成员方法(静态只能访问静态,原因是优先存在)
      class Phone {
      	private String name;
      	private static int price;                    //静态属性
      	public static void run() {                   //静态方法,但name不是静态属性,所以会报错
      		System.out.println(name+"在使用"+price+"块钱的手机");
      	}	
      }
      
      • 可以通过类名.属性调用(推荐),也可以通过对象名.属性调用
      • 静态修饰的内容有一般称为:类属性,类方法,非静态的就是对象(实例)属性,对象(实例)方法
    • final:

      • 修饰类: 该类不能被继承
      • 修饰属性: 该属性只能被赋值一次,相当于变成了常量,如果是局部变量中的引用类型变量,是地址不能变
      • 修饰方法: 该方法不能被重写
    • abstract

    • synchronized

    • volatile

  • 访问修饰符

    • public:

      • 对所有类可见。使用对象:类、接口、变量、方法
    • default:

      • (即默认,什么也不写): 在同一包内可见,不使用任何修饰符。使用对象:类、接口、变量、方法
    • protected:

      • 对同一包内的类和所有子类可见。使用对象:变量、方法。 注意:不能修饰类(外部类)
    • private:

      • 在同一类内可见。使用对象:变量、方法。 注意:不能修饰类(外部类)
      • 私有权限修饰符
      • 被修饰的成员只能在本类中访问
      • 可以提供getxxx(),setxxx()公共方法访问修改成员属性
      • 如果一个类中的方法都是静态的,一定要私有private他的构造方法,目的是不让其他类创建其对象
      class Student {
      	public static void main(String[] args) {
      		Phone s = new Phone(); 
      		s.price = 100;                          //无法访问和赋值
      		System.out.println(s.name+"......."+s.price);
      		s.run();                                //无法调用private方法
      	}
      }
      class Phone {
      	String name;
      	private int price = 500;                    //封装了这个成员变量,修饰符是private
      	private void run() {                        //封装了这个方法
      		System.out.println("他在使用"+price+"块钱的"+name);
      	}	
      }
      

  • 其他关键字

  • this 关键字

    • this表示当前对象的引用,类似python中的self
    • 运用场景: 用来区分成员变量和局部变量重名的情况,就近原则会导致赋值错误
    • 格式: this.name = name; (self.name = name)
  • super 关键字

    • 表示对父类的引用,出现在继承中
    • 格式: super.方法名();或者super(参数1…)(调用父类有参构造)

相关标签: Java