基础语法
1,标识符和关键字
关键字:
标识符:
2,数据类型
强类型语言:
要求变量的使用要严格符合规定,所有变量都必须先定义后使用
弱类型语言:
js,vb等
字节:
3,数据类型拓展
public class demo01 {
public static void main(String[] args) {
//整数扩展: 进制 二进制 0b 十进制 八进制 0 十六进制 0x
int i =10;
int i2= 010;
int i3=0x10;
System.out.println(i);
System.out.println(i2);
System.out.println(i3);
System.out.println("========================================");
//浮点数扩展 银行业务怎么表示?钱
//BigDecimal 类
//float 有限 离散 舍入误差 大约 接近但不等于
//double
//最好完全使用浮点数进行比较
float f=01.f;
double d=1.0/10;
System.out.println(f==d);
float f1=4521456546454646f;
float f2=f1+1;
System.out.println(f1==f2);
System.out.println("=======================================");
//字符扩展
char c1='a';
char c2='中';
System.out.println(c1);
System.out.println((int)c1);
System.out.println(c2);
System.out.println((int)c2);//强制转换
//所有的字符本质还是数字
//编码 Unicode 表 :(97=a 65=A) 2字节 0-65535 EXCEL 2 16 =65536
//U0000 UFFFF
char c3='\u0061';
System.out.println(c3);// a
//转移字符
//\t 制表符
// \n 换行
//布尔值扩展
boolean flag=true;
if (flag){
System.out.println("true");
}
}
}
4,类型转换
低------------------------------------------>高
byte,short,char->int->long->float->double
public class demo02 {
public static void main(String[] args) {
int i=128;
byte b=(byte) i;
//强制转换 (类型)变量名 高--低
//自动转换 低--高
System.out.println(i);
System.out.println(b);
/**
* 低------------------------------------------>高
* byte,short,char->int->long->float->double
* 注意点:
* 1,不能对布尔值进行转换
* 2,不能把对象类型转换为不相干的类型
* 3,在把高容量转换到低容量的时候,强制转换
* 4,转换的时候可能崔仔内存溢出,或者精度问题!
*/
System.out.println("===================");
System.out.println((int)23.7); //23
System.out.println((int)-45.29f);//-45
System.out.println("=======================");
char c='a';
int d = c+1;
System.out.println(d);
System.out.println((char) d);
}
}
import java.time.Year;
public class demo03 {
public static void main(String[] args) {
//操作比较大的数的时候,注意溢出问题
// jdk7新特新,数字之间可以用下划线分割
int money=10_0000_0000;
int years=20;
int total=money*years;
System.out.println(total);//-1474836480 溢出
long total2=money*years;//默认是int ,转换之前已经出现了问题
System.out.println(total2);
long t3=money*((long)years);
System.out.println(t3);
}
}
5,变量
6,运算符
位运算:
字符串连接符:
7,javadoc
流程控制
1,scanner
package scanner;
import java.util.Scanner;
public 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);
}
scanner.close();
}
}
package scanner;
import java.util.Scanner;
public class demo02 {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
System.out.println("使用nextline方式接受:");
if (scanner.hasNextLine()){
String str=scanner.nextLine();
System.out.println("输出的内容为:"+str);
}
scanner.close();
}
}
package scanner;
import java.util.Scanner;
public class demo03 {
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("输入的不是整数数据!");
}
scanner.close();
}
}
package scanner;
import java.util.Scanner;
public class demo04 {
public static void main(String[] args) {
Scanner scanner= new Scanner(System.in);
double sum=0;
int m=0;
System.out.println("输入一组数据:");
while (scanner.hasNextDouble())
{
double x=scanner.nextDouble();
m++;
sum+=x;
System.out.println("你输入了第"+m+"个数据,然后当前结果sum="+sum);
}
System.out.println(m+"个数的和为:"+sum);
System.out.println(m+"个数的平均值是:"+(sum/m));
scanner.close();
}
}
2,顺序结构
3,选择结构
九九乘法表:
package Forwhile;
public class JJBSY9981 {
public static void main(String[] args) {
for (int j = 1; j <=9; j++) {
for (int i = 1; i <=j; i++) {
System.out.print(j+"*"+i+"="+j*i+"\t");
}
System.out.println();
}
}
}
增强for循环
4,break,continue
打印三角形
package Forwhile;
public class Sanjiao {
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
for (int j = 5; j >= i; j--) {
System.out.print(" ");
}
for (int j = 1; j <=i; j++) {
System.out.print("* ");
}
System.out.println();
}
}
}
方法
1,什么是方法?
2,方法的定义与调用
3,方法的重载
4,可变参数
5,递归调用
数组
1,数组声明和创建
2,内存分析
3,三种初始化
4,数组使用
package arrays;
public class UserArray {
public static void main(String[] args) {
int [] arrays={1,2,3,4,5};
//打印全部数组元素
for (int i = 0; i < arrays.length; i++) {
System.out.println(arrays[i]);
}
System.out.println("================");
//计算所有元素的和
int sum=0;
for (int i = 0; i < arrays.length; i++) {
sum+=arrays[i];
}
System.out.println(sum);
System.out.println("================");
//查找最大元素
int max=arrays[0];
for (int i = 0; i < arrays.length; i++) {
if (arrays[i]>max)
max=arrays[i];
}
System.out.println("max:"+max);
}
}
package arrays;
public class Use2 {
public static void main(String[] args) {
int[] arrays={1,2,3,4,5};
//foreach
// for (int array:arrays) {
// System.out.println(array);
// }
// printArray(arrays);
int[] reverse= reverse(arrays);
printArray(reverse);
}
//打印数组元素,数组作为方法入参
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.println(arrays[i]+" ");
}
}
//数组作返回值,翻转数组
public static int[] reverse(int[] array){
int[] result=new int[array.length];
//反转操作
for (int i=0,j=result.length-1;i<array.length;i++,j--){
result[j]=array[i];
}
return result;
}
}
5,二维数组
6,Arrays类
package arrays;
import java.util.Arrays;
public class Use3 {
public static void main(String[] args) {
int[] a={12,4,6,85,2,45,51};
Arrays.sort(a);
System.out.println(Arrays.toString(a));
}
}
7,冒泡排序
package arrays;
import java.util.Arrays;
public class Use4 {
public static void main(String[] args) {
//冒泡排序
/**
* 1,比较数组中,两个相邻的元素,如果第一个数比第二个数大,就交换他们的位置
* 2,每一次比较都会产生出一个最大或者最小的数字
* 3,下一轮则可以少一次排序
* 4,依次循环知道结束
*/
int [] a={52,4,22,15,3,6,8,54,55,221};
int [] sort=sort(a);
System.out.println(Arrays.toString(sort));
}
public static int[] sort(int[] array){
//临时变量
int t=0;
//外层循环,判断我们这个要走多少次
for (int i = 0; i < array.length; i++) {
//内层循环,比较判断两个数,如果第一个数比第二个数打,则交换位置
for (int j = 0; j < array.length-1; j++) {
if (array[j+1]>array[j])
{
t=array[j];
array[j]=array[j+1];
array[j+1]=t;
}
}
}
return array;
}
}
8,稀疏数组
面向对象
1,对象
2,方法
方法调用
静态方法:static关键字
非静态方法:实例化
值传递:
引用传递:
3,类与对象的创建
4,构造器
1,使用new 关键字,必须要有构造器(本质是在调用构造器);
2,用来初始化值.
//一旦定义了有参构造,就必须先定义无参构造
快捷键:alt+insert 自动生成构造器
总结:
构造器:
1,和类名相同
2,没有返回值
作用:
1,new 本质是在调用构造方法
2,初始化对象的值
注意点:
1,定义有参构造之后,如果想使用无参构造,显示的定义一个午餐的构造
2,this. =
3,alt+insert
5,小结
6,封装
快捷键:alt+insert
作用:
1,提高程序安全性,保护数据
2,隐藏代码的实现细节
3,统一接口
4,系统可维护增加了
7,继承
super
super注意点:
1,super调用父类的构造方法,必须在构造方法的第一个
2,super必须只能出现在子类的方法或者构造方法中!
3,super和this不能同时调用构造方法
VS this:
代表的对象不同:
this:本身调用者这个对象
super:代表父类对象的应用
前提:
this:没有继承也可以使用
super:只能在继承条件才可以使用
构造方法:
this():本类的构造
super():父类的构造
方法重写
重写:需要有继承关系,子类重写父类的方法
1,方法名必须相同
2,参数列表必须相同
3,修饰符,范围可以扩大但不能缩小 public>protected>default>private
4,跑出的异常,范围可以被缩小不能被扩大 ClassNotFoundException–> Exception(大)
重写,子类的方法和父类必要一致,方法体不同!
为什么需要重写:
父类的功能,子类不一定需要,或者不一定满足
8,多态
注意:
1,多态是方法的多态,属性没有多态
2,父类和子类,有联系,类型转换异常,ClassCastException
3,存在条件:继承关系,方法需要重写,父类引用指向子类对象! Father f1=new Son();
以下方法不能重写:
1.static 方法,属于类,他不属于实例
2.final 常量
3.private 方法
instance of
主要是看x是不是y的父类
类型转换
总结
1,父类引用指向子类的对象
2,把子类转换为父类,向上转型
3,把父类转为子类,向下转型,强制转换
4,方便方法的调用,减少重复的代码,简洁
9,static关键字
10,抽象类
特点:
1,不能new这个抽象类,只能靠子类去实现它,约束
2,抽象类中可以写普通的方法
3,抽象方法必须在抽类中
抽象的抽象:约束
11,接口
12,内部类
1,成员内部类
2,静态内部类
3,局部内部类
4,匿名内部类
异常
1,error 和exception
2,异常处理
快捷键:ctrl +alt+t
3,自义定异常
注:本笔记于b站up主“遇见狂神说”https://www.bilibili.com/video/BV12J41137hu
处学习记录,仅供学习与参考