JavaSE笔记

Java基础

本笔记借鉴于狂神说

卸载JDK

1.删除java的安装目录

2.删除JAVA_HOME

3.删除path下关于java的目录

4.java -version

编译型-解释型

JAVA语言是一种编译型-解释型语言，其实，确切的说java就是解释型语言，其所谓的编译过程只是将.java文件编程成平台无关的字节码.class文件，并不是向C一样编译成可执行的机器语言。

类型	原理	优点	缺点
编译型语言	通过专门的编译器，将所有源代码一次性转换成特定平台（Windows、Linux 等）执行的机器码（以可执行文件的形式存在）。	编译一次后，脱离了编译器也可以运行，并且运行效率高。	可移植性差，不够灵活。
解释型语言	由专门的解释器，根据需要将部分源代码临时转换成特定平台的机器码。	跨平台性好，通过不同的解释器，将相同的源代码解释成不同平台下的机器码。	一边执行一边转换，效率很低。

数据类型

基本数据类型:

数值类型：{

a.整数类型:

byte占一个字节范围:-128-127
short占2个字节范围:-32768-32767
int占4个字节范围:-2147483648-2147483647
long占8个字节范围:-9223372036854775808-9223372036854775807

b.浮点类型:

float占4个字节
double占8个字节

c.字符类型:char占2个字节

}

boolean类型:占1位其值只要true和false两个

引用数据类型:类、接口、数组

什么是字节

位(bit) : 是计算机内部数据储存的最小单位，11001100是一个八位二进制数。
字节(byte) : 是计算机中数据处理的基本单位，习惯用大写B来表示。
1B （byte,字节）= 8bit(位)
字符: 是指计算机中使用的字母、数字、字和符号
1bit表示1位
1Byte表示一个字节 1B=8b
1024B=1KB
1024KB=1M
1024M=1G

数据类型拓展

public class MyTest {
	public static void main(String[] args) {
		// 整数拓展:   进制 	二进制0b   十进制   	八进制0 	十六进制0x
		//JDK7新特性，数字之间可以用下划线分割
		int i = 10_0000_0000; 
		int i2 = 010; //八进制0
		int i3 = 0x10;//十六进制0x  	0~9  A~F 16
		//================================
		System.out.println(i); //1000000000
		System.out.println(i2); //8
		System.out.println(i3);//16
		//================================
		//浮点数拓展?  银行业务怎么表示?钱
		//答:用BigDecimal  数学工具类
		//float  有限  离散    舍入误差	大约 	接近但不等于
		//double
		//最好完全避免使用浮点数进行比较!!!
		float f = 0.1f;//0.1
		double d = 1.0/10; //0.1
		System.out.println(f==d);//false
		
		float d1 = 12123134654f;
		float d2 = d1 + 1;
		System.out.println(d1==d2);//true
		//================================
		//字符拓展?
		//所有的字符本质还是数字
		//编码  Unicode 表: (97 = a  65 = A) 2字节 	0-65536
		char c1 = 'A';
		char c2 = '中';
		char c3 = '\u0061';
		System.out.println(c1);//A
		System.out.println(c2);//中
		System.out.println(c3);//a
		System.out.println((int)c1);//65
		System.out.println((int)c2);//20013
		
		//转移字符
		// \t 制表符
		// \n 换行	...
		
		// ==:如果比较的对象是基本数据类型,则比较的是数值是否一致；如果比较的对象是引用数据类型，则比较的是地址是否一致
		String str1 = new String("hello world");
		String str2 = new String("hello world");
		System.out.println(str1==str2);//false
		
		String str3 = "hello world";
		String str4 = "hello world";
		System.out.println(str3==str4);//true
	}
}

类型转换

由于Java是强类型语言，所以要进行有些运算的时候需要用到类型转换

低 ----------------------->高

byte,short,char->int->long->float->double

运算中，不同类型的数据先转化位同一类型，然后进行运算。

强制转换:（类型）变量名高--低

自动转换：低--高

注意点：

1.不能对布尔值进行转换

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

3.在把高容量转换到低容量的时候，强制转换

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

位运算

A = 0011 1100
B = 0000 1101
---------------
A&B = 0000 1100  与 两个位都为1时，结果才为1，否则为0
A|B = 0011 1101  或 两个位都为0时，结果才为0，否则为1
A^B = 0011 0001  异或 两个位相同为0，相异为1
~B = 1111 0010	取反 0变1，1变0
<< 相当于 *2
>> 相当于/2
0000 0000 0
0000 0001 1
0000 0010 2
0000 0011 3
0000 0100 4
0000 1000 8
0001 0000 16
2*8即2<<3

Java未赋值变量的默认初始值

在 Java 程序中，任何变量都必须经初始化后才能被使用。当一个对象被创建时，实例变量在分配内存空间时按程序员指定的初始化值赋值，否则系统将按下列默认值进行初始化：

数据类型	初始值
byte	0
short	0
int	0
long	0L
char	'u0000'
float	0.0f
double	0
boolean	false
所有引用类型	null

注意：一个具有空值“null”的引用不引用任何对象。试图使用它引用的对象将会引起一个异常。

字符串拼接注意点

int a = 10;
int b = 20;
System.out.println(""+a+b);//结果为1020 空字符串后面为拼接
System.out.println(a+b+"");//结果为30 先运算后拼接

运算符的优先级

优先级	运算符	结合性
1	()、[]、{}	从左向右
2	!、+、-、~、++、--	从右向左
3	*、/、%	从左向右
4	+、-	从左向右
5	«、»、>>>	从左向右
6	<、<=、>、>=、instanceof	从左向右
7	==、!=	从左向右
8	&	从左向右
9	^	从左向右
10	\|	从左向右
11	&&	从左向右
12	\|\|	从左向右
13	?:	从右向左
14	=、+=、-=、*=、/=、&=、\|=、^=、~=、«=、»=、>>>=	从右向左

Java流程控制与方法

Scanner对象

next():

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

nextLine():

以Enter为结束符，也就是说 nextLine()方法返回的是输入回车之前的所有字符。
可以获得空白。

方法的定义

方法包含一个方法头和一个方法体。下面是一个方法的所有部分:

修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
返回值类型：方法可能会返回值。returnValueType是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType是关键字void。
方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
形式参数：在方法被调用时用于接收外界输入的数据。
实参：调用方法时实际传给方法的数据。
方法体：方法体包含具体的语句，定义该方法的功能。

方法的重载

方法名称必须相同。
参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）。
方法的返回类型可以相同也可以不同。
仅仅返回类型不同不足以成为方法的重载。

可变参数

JDK1.5开始，Java支持传递同类型的可变参数给一个方法。在方法声明中，在指定参数类型后加一个省略号(...)。一个方法只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

递归

递归即是自己调用自己，利用递归可以用简单的程序来解决一些复杂的问题。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序地代码量。递归的能力在于用有限的语句来定义对象的无限集合。

递归包括两个部分：

1、递归头：什么时候不调用自身方法。如果没有头，将陷入死循环

2、递归体：什么时候需要调用自身方法。

public class Test{
    //利用递归算法求一个数的阶层
    public static void main(String[] args){
        System.out.println(f(3));//6
    } 
    public static int f(int n){
        if(n==1){
            return 1;
        }else{
            return n*f(n-1);
        }
    }
}

Java内存

1、栈：存放基本数据类型（会包含这个基本类型的具体数值）；引用对象的变量（会存放这个引用在堆里面的具体地址）

2、堆：存放new的对象和数组；可以被所有的线程共享，不会存放别的对象引用

3、方法区：可以被所有的线程共享；包含了所有的class和static变量

冒泡排序

public class MyDemo{ 
	  public static void main(String args[]){
		  int[] a = {1,457,286,48,6,58,45,2};  
		  int[] sort = sort(a);//调用完我们自己写的排序方法以后，返回一个排序后的数组 
		  System.out.println(Arrays.toString(sort));//打印该数组
	}
	  //冒泡排序
	  //1、比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
	  //2、每一次比较，都会产生一个最大或者最小的数字
	  //3、下一轮则可以少一次排序；
	  //4、依次循环，直到结束！ 
	  public static int[] sort(int[] arr){
		  //临时变量
		  int temp = 0;
		  //外层循环，判断我们这个要走多少次
		  for(int i = 0; i < arr.length-1; i++){
			  boolean flag = false; //通过flag标识位减少没有意义的比较
			  //内层循环，比较判断两个数，如果第一个数比第二个数大则交换位置
			  for(int j = 0; j < arr.length-1-i; j++){
				  if(arr[j]>arr[j+1]){
					  temp = arr[j+1];
					  arr[j+1] = arr[j];
					  arr[j] = temp;
					  flag = true;
				  }
			  }
			  if(flag==false){
				  break;
			  }	  
		  }
		  return arr; 
	  }
}

值传递和引用传递

//值传递
public class MyDemo2{ 
	public static void main(String[] args) {
		int a = 1;
		System.out.println(a);//1
		MyDemo2.change(a);
		System.out.println(a);//1
	}
	
	//返回值为空
	private static void change(int a) {
		a = 10;
	}
	  
}

//引用传递：对象，本质还是值传递
public class MyDemo2{ 
	public static void main(String[] args) {
		Person person = new Person();
		System.out.println(person.name);//null
		MyDemo2.change(person);
		System.out.println(person.name);//憬荃
	}
	//返回值为空
	private static void change(Person person) {
		//person是一个对象：指向的 ---> Person person = new Person();这是一个具体的人，可以改变属性！
		person.name = "憬荃";
	}  
}
class Person{
	String name;//null
}

super与this

super调用父类的构造方法，必须在构造方法的第一个
super必须只能出现在子类的方法或者构造方法中
super和this不能同时调用构造方法
代表的对象不同:

this:本身调用者这个对象

super:代表父类对象的引用

前提：

this:没有继承也可以使用

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

方法的重写

重写：需要有继承关系，子类重写父类的方法！

1、方法名必须相同

2、参数列表必须相同

3、修饰符：范围可以扩大但不能缩小 public>protected>default>private

4、抛出的异常：范围可以被缩小但不能扩大： ClassNotFoundException --> Exception

重写即子类的方法和父类必须一致：方法体不同！

多态注意事项

1、多态是方法的多态，属性没有多态

2、父类和子类，有联系。若没有，则类型转换异常(ClassCastException)

3、存在条件：继承关系，方法需要重写，父类引用指向子类对象，但是不能调用子类独有的方法

4、以下方法不能重写(static方法：属于类它不属于实列、final常量、private方法)

5、对象能执行哪些方法主要看对象左边的类型和右边关系不大！子类重写了父类的方法，则执行子类的方法。

Static

//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class MyDemo4{ 
	public static void main(String[] args) {
		System.out.println(random());
		System.out.println(PI);
	}  
}

posted @ 2020-12-19 13:37 憬荃阅读(141) 评论(0) 收藏举报

刷新页面返回顶部

憬荃