-
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;
}
}
-
数组
-
概念
- 类似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 返回数组的长度
- 1 遍历
-
二维数组
- 二维数组不要求矩阵对齐
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…)(调用父类有参构造)
152
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
