Java面向对象笔记

一、基础语法

1、数据类型

(1)分类

4类8种基本数据类型+引用数据类型

基本数类型：

​ 整型

​ byte short int long

​ byte: [-128,127]

​ int:是默认的整型的数据类型

System.out.println(123);//这里的123没有规定数据类型，其实是int类型

​ 浮点型

​ float double

​ double:浮点型的默认的数据类型

System.out.println(123.12);//123.12没有规定数据类型，其实是double
float f = 123.12f;//编译报错

​ 字符型

​ char

char character = 'A';
char character = '\U0000';
char character = 0;

asc码表，每一个字符都有对应的整型的值

​ 布尔型

​ boolean

​ 一个true，一个false

引用数据类型：

​ 类(String Date…) class

​ 接口 interface

​ 数组 []

​ 枚举 enum

(2)转换

大转小

​ byte < short < int < long < float < double

​ 强制转

//对于基本数据类型的强制转换：注意精度丢失
int num = 20;
byte num1 = (byte)num;

​ 引用数据类型：

​ 大：父类型，父接口

​ 小：子类，接口的实现类

​ 大转小，强制转

public class A{
   }
public class B extends A{
   }
public class Test{
   
    
    public static void main(String[] args){
         
        A a = new A();
        B b = (B)a;//编译通过，运行报错  ClassCastException 类型转换错误
        
        A a1 = new B();
        B b1 = (B)a1;//编译通过，运行通过
        
    }
    
}

小转大：

​ 自动转

基本数据类型中的特殊情况：

byte num = 123;//编译通过，运行正常

//char和byte与short之间的转换都需要强制转换
char ch = 'A';
byte num = (byte)ch;
ch = (char)num;

//char理解为比int小
int num = 'A';
char ch1 = (char)num;

2、运算符

(1)算术运算符

+ - * / %

int num = 10/3;  //3
int num = 1/0;   //编译通过，运行报错  /by  zero
double num = 1.0/0;  //无穷大
double num = 1.0/0.0;  //非数  NaN

算术运算的结果的数据类型

//int一下的数据类型进行运算，类型都会提升到int
byte num = 1;
short num1 = 2;

int result = num + num1;

其他的所有数据类型的算术运算，结果都是以较大的数据类型为准

(2)赋值运算符

=      +=    -=     *=     /=     %=

赋值运算= 先计算右边的表达式，然后将右边的表达式结果赋值给左边的变量

int num = 10;
num += 1; // num = num + 1;


byte num = 127;
num = num +1; //编译报错

num += 1;//编译通过，运行结果会有精度丢失

(3)递增、递减运算符

++ –

int i = 1;
int a = i++ + i++ + i++;
int b = ++i + ++i + ++i;

System.out.println(i);//7
System.out.println(a);//6
System.out.println(b);//18

i++既可以作为表达式，又可以作为单独的语句

难点是i++或者++i作为表达式

++前置，先运算i的值，然后返回++i这个表达式的结果

++后置，先返回i++的结果，然后再运算i的值

(4)位运算符

数据是以补码的形式进行存储和运算的

正数的补码是其本身

负数的补码是源码-(符号位不变，其余各位取反)->反码-(+1)->补码

了解

<<     >>     >>>

<<

右侧以0来补齐

>>

左侧以符号位补齐

>>>

左侧以0补齐

|

&

^

(5)逻辑运算符

&
&&
|
||
!

&&

左侧为false，右侧不进行计算，直接返回false

||

左侧为true，则右侧不进行运算，直接返回true

(6)三目运算符

a?b:c

a成立，则运算b，否则运算c

3、流程控制语句

(1)选择

if

单分支：
if(条件1){
	语句1
}

双分支:
if(条件1){
	语句1
}else{
	语句2
}

多分支(最多进入一个分支)
if(条件1){
	语句1
}else if(条件2){
	语句2
}...else if(条件n){
	语句n
}[else{
	
}]

switch

switch(key){
case 值1:
	语句1;
case 值2:
	语句2;
case 值n:
	语句n;
[
default:
	语句;
]
}

key:类型可以为byte short char int String enum

case具有穿透性，可以使用break关键字阻止case的穿透

case的位置可以随便写

default的位置都可以随便写，所有的case都不满足的时候进入default

最后一个分支建议加break

(2)循环

while

一般来说，我们会在while执行前定义一个变量
条件中对变量做判断
循环体的最后修改变量的值
while(条件){
	循环体;
}


int num = 1;
while(num<10){
	//....
	num++;
}

do…while

do{
   
    循环体;
}while(条件);

do…while至少执行1次循环体

for

for(语句1;表达式2;语句3){
   
    循环体4;
}

执行顺序：1 - 2 - 4 - 3 - 2 -4 -3 -2 -4 -3 …直到2返回false为止

语句1只执行1次

语句1：初始化

表达式2：对语句1中初始化的变量做判断，是否满足循环条件

语句3：循环体执行完后更改变量的值

增强for循环 foreach

遍历数组

int[] array = {
   1,2,3,4,5};
for(int num : array){
   
    System.out.println(num);
}

continue

​ 结束本层循环的本次循环，继续本层循环的下次循环

loop:for(int i = 0; i <= 10; i++){
   
    for(int j = 0; j <= 10; j++){
   
    
    	if(j == 5){
   
            continue loop;
        }
	}
  
}

break

​ 结束本层循环