01 java 学习

hello world

代码

 public class hello{public static vold main(String[] args){System.out.print("hello,world");}}

编译

编译  javac hello.java  ---> 会生成一个class文件
运行  java hello      ----> 运行

注释

数据类型

基本类型种类有8种：

//整数
byte num1=10;
short num2=20;
int  num3=30;
long  num4=30L;  //long类型要再数字后面加L
//小数
float num5=50.1F;//lFloat 类型要在数字后面加个F
double num6=3.141592653549；
//字符
char name ='A';
//字符串，string 不是关键词，是类
String namea="中国";
//布尔值：代表是否
boolean flag= true；
boolean falg=false;

引用类型
1. 类
2. 接口
3. 数组

类型装换
- 不能对布尔值进行转换
- 不能把对象类型转换为不相干的类型
- 在把高容量转换到低容量的时候，强制转换。通常（强制转换类型）变量
- 转换的时候可能存在内存溢出，或者精度问题

变量、常量

类变量
实例变量
局部变量
public class Variable{static int allcliks=0;//类变量   直接引用staticString str="hello world"；//实例变量：从属于对象；直接初始化，可以不赋值；如果不初始化，就是这个类型的默认值public void method(){int i =0 ;//局部变量，是在方法里面的：必须声明和初始化值；只在局部方法内使用}
}

常量：初始化后不能再改变值！不会变动的值

final 常量值=值;
final double PI=3.14
常量名一直使用大写字符。public class demo09{static final double PI=3.14;public static void main(String[] args){System.out.println(PI);}
}

变量的命名规则

所有变量、方法、类名：见名知意
类成员变量：首字母小写和驼峰原则：monthSalary
局部变量：首字母小写和驼峰原则
常量：大写字幕和下划线：MAX_VALUE
类名：首字母大写和驼峰原则：Man，GoodMan
方法名：首字母小写和驼峰原则：run()，runRun()

运算符

public class Demo4{public static void main(String[] args){int a =3;int b =a++; //执行完这行代码后，先给b赋值，再自增int c =++a; //执行完这行代码前，先自增，再给c赋值System.out.println(a);//输出5System.out.println(b);//输出3System.out.println(c);//输出5}
}

包机制，javadoc

java 流程

do…while循环

对于while语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。
do...while 循环和while 循环相似，不同的是， do...while 循环至少执行一次。
```
do {//代码语句
}while();
```
While 和do-while的区别：
- while 先判断后执行。dowhile是先执行后判断！
- Do-while总是保证循环体会被至少执行一次！这是他们主要的差别。

for循环

for 循环增强

public class Demo5{public static void main(String[] args){int[] numbers = {10,20,30,40,50}; //定义了一个数组for (int x: numbers){System.out.println(x);}System.out.println("==============")for(int i =0;i<5;i++){System.out.println(numbers[i]);}}

方法

System.out.println() System 为类，out为对象， println 为方法

翻译过来：调用system 类里的out 对象的println 方法

java方法是语句的集合，他们在一起执行一个功能
- 方法是解决一类问题的步骤的有序组合
- 方法包含于类对象中
- 方法在程序中被创建，在其他地方被引用

设计方法的原则：方法的本意是功能快，就是实现某个功能的语句块的集合。我们设计方法的时候，最好的保持方法的原子性，就是一个方法只完成1个功能，这样利于我们后期的扩展。

public static void main  //static 修饰符，表示静态，在内存中开辟一段空间，运用存储，可以直接被调用// void 表示返回值 void表示空
public int add(int a ,int b )    // int 表示方法的返回值，add为方法名

方法的定义

Java的方法类似于其他语言的函数，是一段用来完成特定的功能的代码片段，一般情况下，定义一个方法包含以下语法：
方法包含一个方法头和一个方法体。下面是一个方法的所有部分：
- 修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
- 返回值类型：方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但是没有返回值。在这种情况下，returnValueType是关键词void。
- 方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
- 参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参和变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
  - 形势参数：在方法被调用时用于接受外界输入的数据。
  - 实参：调用方法时实际传递给方法的数据。
- 方法体：方法体包含具体的语句，定义该方法的功能。
```
修饰符 返回值 方法名(参数类型 参数名){···方法体···return 返回值；
}
```

方法调用

调用放方法：对象名.方法（实参列表）
JAVA支持两种调用方法的方式，根据方法是否返回值来选择
当方法返回一个值的时候，方法调用通常被当做一个值。例如：
```
int larger = max(30,40)
```
如果方法返回值是void，方法调用一定是一条语句。
```
System.out.println("hello,world")
```

方法的重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数。
方法的重载的规则：
- 方法名称必须相同。
- 参数列表必须不同（个数不同，或类型不同，参数排列顺序不同等）
- 方法的返回类型可以相同也可以不相同。
- 仅仅返回类型不同不足以成为方法的重载
实现理论：方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。

命令行传参

有时候你希望运行一个程序时候再传递给它消息。这要靠传递命令行参数给main（）函数实现

public class Commandline {publick static void main(String[] args ) {for(int i=0;i<args.length;i++){System.out.println("args["+i+"]"+args[i]);}}
}

可变参数

JDK1.5 开始，JAVA支持传递同类型的可变参数给一个方法。
在方法声明中，在指定参数类型后加一个省略号（…）

一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在他之前声明。

public static void printMax(double...numbers){if(numbers.lenght ==0){System.out.println("No argument passed");return;}double result = numbers[0];//排序！for (int i =1;i< numbers.length;i++){if (numbers[i]>result){result =number[i]}}System.out.println("The max value is "+ result);
}

其他例子

public class Demo4{public static void main(String[] args){Demo4 demo4 = new Demo4();demot.test(...i:1,2,3,4,5);}public void test(int ...i){System.out.println(i[0]);System.out.println(i[1]);}public viod test()
}

数组

首先必须声明数组变量，才能在程序中使用数组

dateTpye[] arrayRefVar; //首先的方法
或
dateType arrayRefVar[];//效果相同，但不是首选方法

java语言首选new操作符来创建数组，语法如下：
```
datetype[] arrayRefVar = new dateType[arraySize];
```
数组的元素是通过索引访问的，数组索引从0开始。
获取数组长度：arrays.length

内存分析

java内存分析
- 堆：1）存放new的对象和数组
  
  2）可以被所有的现场共享，不会存放别的对象引用
- 栈：1）存放基本变量类型（会包含这个基本类型的具体数值）
  
  2）引用对象的变量（会存放这个引用在堆里面的具体地址）
- 方法区：1）可以被所有的线程共享
  
  2）包含了所有的class和static变量

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0KqaxI7R-1650688112316)(/Users/tianzhi/Library/Application Support/typora-user-images/image-20220420193234745.png)]

三种初始化

1、静态初始化

int[] a= {1,2,3};//一旦被初始化，后续无法动态增加
Man[] mans = {new Man(1,1),new Man(2,2)};

2、动态初始化

int[] a = new int[2];
a[0]=2;
a[1]=3;

3、数组的默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

4、数组的四个基本特别

其长度是确定的。数组一旦被创建，它的大小是不可以被改变的。
其元素必须是相同类型的，不允许出现混合类型
数组中的元素可以任何数据类型，包括基本类型和引用类型。
数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型的，数组对象本身是在堆中的

数组使用

翻转数组
public static int[] reverse(int[] arrays){int[] result = new int[arrays.length];for(i=0,j=arrays.length-1;i<arrays.length;i++,j--){result[j]=array[i];}System.out.println(result)
}

冒泡排序

比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
每一次比较，都会产出一个最大，或者最小的数字；
下一次轮可以少一次排序!
一次循环，直到结束

public static void sort(int[] array){int temp=0;//外层循环，判断我们这个要走多少次；for(int i =0;i < array.length-1;i++){//内层循环，判断两个数，如果第一个数，比第二个数大，则交换位置for（int j=0;j<array.length-1 -i ;j++）{if(array[j+1]>array[j]){temp = array[j];array[j]=array[j+1];array[j+1]=temp}}return array;}}

面向对象

1、面向过程思想

步骤清晰简单，第一步做什么，第二步做什么

面对过程适合处理一些较为简单的问题

2、面向对象思想

物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对每个分类下的细节进行面向过程的思索。

对象对象适合处理复杂的问题，适合处理需要多人写作的问题！

对于描述复杂的食物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

面向对象编程的本质是：以类的方式组织代码，以对象的组织（封装）数据。

三大特性：

封装:
继承
多态

3、创建与初始化对象

使用new关键字创建对象
使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化及对类中构造器的调用
类中的构造器也被称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有一下两个特点
- 必须和类的名字相同
- 必须没有返回类型，也不能写void
构造器必须要掌握

mac 快捷键，command+n，可以自动生成类似于python __ init __

先定义类变量

再定义构造器，选择传递的参数
- 构造器本质上和类名相同，没有返回值
- 作用：new 本质在调用构造方法。初始化对象的值
- 注意点：定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造。
```
java --->class
public class Person{//一个类即使什么都不写，它也会存在一个方法
//显示的定义构造器 String name;//实例化初始值
//1、使用new关键字，本质是在调用构造器 public Person(){this.name = 'qinjiang'}
}
```

4、面向过程的内存过程

堆里面有个特殊的区叫方法区

栈里面一般是方法和一些引用

回顾方法及加深

1、方法的定义

修饰符
返回类型
break：跳出switch，结束循环和return的区别：表示方法结束，返回一个结果！
方法名：注意规范niHao。见名知意
参数列表：（参数类型，参数名）

异常抛出

public void readFile(String file) throws IOException{}

2、方法的调用

静态方法:有static，不用实例化，直接调用student.say()。跟python 类装饰器@staticmethod 一样。

非静态方法：没有static，每次调用必须实例化，比如new Student().say()

public class Demo2{public static void main(String[] args){//实例化这个类 new//对象类型 对象名 = 对象值//object A = new Object（）Student student = new Student();student.say();}
}
-------------------------
public void a(){b();//两个都为非静态方法，可以直接调用方法b，不用初始化方法
}public void b(){}--------------------------
public static void a(){b();//主调用方法为静态方法，被调用方法为非静态方法，无法直接调用
}
//static方法，和类一起加载的，当Demo2这个类存在的时候，静态方法就已经存在了//类实例化之后，才被创建 ，所以无法被调用
public void b(){}

形参和实参

值传递和引用传递

一个类里面，只有一个public class，但是可以有多个class

this关键字

类似python中的self。定义类变量时，直接声明变量即可。
```
```java
```

public class Student(){
String name;
int age;

public void study(){
System.out.println(this.name+“在学习”)；
}
}
```

对象总结

封装

该露的露，该藏的藏

我们程序设计要追求”高内聚，低耦合“。

高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；

低耦合：仅暴露少量的方法给外使用。
封装（数据的隐藏）

通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

记住这句话就够了：**属性私有，get/set **

public class Student{private String name;Private int id;Private char sex;//提供一些可以操作这个属性的方法！//提供一些public 的get，set方法//get 获得这个数据public String getName(){return this.name;}//set 给这个数据设置值public void setName(String name){this.name=name;  }
}

public static void main(String[] args){Student s1 = new Student();S1.name //爆红，无法访问，因为name 为私有属性}

封装的作用

提高程序的安全性，保护数据
隐藏代码的实现细节
统一接口
系统可维护增加了

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
extends 的意思是”拓展“。子类是父类的拓展。
JAVA中类只有单继承，没有多继承
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等
继承关系的两个类，一个位子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示
子类和父类之间，从意义上讲应该具有”is a“的关系
object类
super

继承关系快捷键，mac：ctrl+H

public class Student extends Person{}

super.属性   调用的是父类的属性
this.属性    调用的是子类的属性public class Student entends Person{public void test1(String name){print();this.print();super.print();}
}
-----------------------------
public class Student extends Person {public Student(){super();System.out.println("student 无参数执行了")}public Student(String name){this.name = name;}private String name="qinjiang";public void print(){System.out.printlin("Student");}
}

Super 注意点：1、super调用父类的构造方法，必须在构造方法的第一个2、super必须只能出现在子类的方法或者构造方法中！3、super和this不能调用构造！Vs this：
//  代表的对象不同：this：本身调用这个对象super：代表父类对象的应用
//  前期：super：只能在继承条件下可以使用
//  构造方法:this();本类的构造super():父类的构造！

方法重写

如上图。

静态的方法和非静态的方法区别很大！
//静态的方法：方法的调用只和左边，定义的数据类型有关
//非静态的：重写  用command+n，override 方法

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

方法名必须相同
参数列表列表必须相同
修饰符：范围可以扩大,但是不能缩小：public>Protected >default > private
抛出的异常：范围可以被缩小，但是不能扩大

ClassNotException -->Exception(大)

重写，子类的方法和父类必要一致，方法体不同！

多态

即统一方法可以根据发送对象的不同而采用多种不同的行为方式。

public static void man(String[] args){//一个对象的实际类型是确定的//new Student();//new Person();//可以指向一个类的实际对象，他的类型是确定的，比如是Student（）//但是，可以指向的引用类型就不确定了：父类的引用指向子类//Student 能调用的方法都是自己或者继承父类的！Student s1 = new Student();
//Person 父类型，可以指向子类，但是不能调用子类独有的方法
//可以执行的引用类型就不确定了：父类的引用指向子类Person s2= new Student(); Object s3 = new Student()；//对象能执行哪些方法，主要看对象左边的类型，和右边的关系不大！
}

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
多态存在的条件
- 有继承关系
- 子类重写父类的方法
- 父类引用指向子类对象

总结：

使用父类类型的引用指向子类的对象；
该引用只能调用父类中定义的方法和变量
如果子类中重写了父类中的一个方法，那么在调用这个方法时，将会调用子类中的这个方法；（动态链接，动态调用）
变量不能被重写（覆盖），”重写“的概念只针对方法，如果在子类中”重写了“了父类中的变量，那么在编译时会报错。

注意：多态是方法的的多态，属性没有多态性

instanceof

类型转换~ 引用类型转换

判断一个对象是什么类型

public static void main(String[] args){//Object > Person > Student//Object Object object = new Student();System.out.println(object instanceof Student); //TrueSystem.out.println(object instanceof Object); //trueSystem.out.println(object instanceof Person); //true System.out.println(object instanceof Teacher); //FalseSystem.out.println(object instanceof String);//False
}

System.out.println(x instanceof Y) 这款代码能不能编译通过，判断X跟Y是否存在父子关系。 x表示实例化变量，Y表示类名

父子转换： 父转子，需要强制转换，且可以使用子类和父类方法；子转父，强制转换，可能会丢失子类独有的方法。

static 关键词总结

private static int age ;//静态变量
private double score ; //非静态变量

面向对象执行顺序

静态代码--->匿名代码--->构造方法

匿名方法{}，作用是赋初始值

抽象类 abstract

//abstract 抽象类：类entends：是单继承的（但是接口可以多继承）
public abstract class Action {//约束~有人帮我们实现~//abstract，抽象方法，只有方法名字，乜有方法的实现。public abstract void doSomething();//1.不能new这个抽象类，只能靠子类去实现它：约束！
}

接口

普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有！
接口：只有规范！自己无法写方法_{专业的约束！约束和实现分离：面向接口编译}
接口就是对方，定义的是一组规则
接口的本质是七月，就像我们人间的法律一样，制定好后大家都遵守
oo的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具体抽象能力的语言（比如C++、java、C#），就是因为设计模式所研究的，实际上就是如何合理的去抽象

声明类的关键字是class，声明接口的关键字是interface

//interface 定义的关键字
public interface UserService {//接口中的所有定义其实都是抽象的publicvoid run(String name);void delete(String name);void update(String name);void query(String name);
}
//类 可以实现接口 implements
//
public class UserServiceImpl implements UserService{}

内部类

内部类就是在一个类的内部再定义一个类，比如A类中定义了一个B类，那么B类相对于A类来说就称为内部类，而A类相对B类说就是外部类了。
成员内部类
静态内部类
局部内部类
匿名内部类
lambda表达式

public class Outer(){private int id；public void out(){System.out.println("这是外部类的方法")}public class Inner{public void Inner(){System.out.println("这是内部类的方法")}}
}public class Application{public static void main(String[] args){Outer outer=new Outer();Outer.Inner inner=Outer.new Inner();}
}

异常机制

抛出异常
捕获异常
异常处理五个关键字

try、catch、finally、throw、throws

public class Test{public static void main(String[] args){int a = 1;int b =0;try{System.out.println(a/b);}catch(ArithmeticException e)//假设他叫e{System.out.println("B不能为0")finally{//处理善后工作System.out.println("finally");}}}
}
------------------------------
最高捕获异常try{new Test().a();
}catch (Throwable e){System.out.println("程序出现异常，变量b不能为0")；
}
------------------------------多个异常捕获
try{} catch(){} catch(){}输出：程序出现异常，变量b不能为0； //finally 可以不要finally，假设IO，资源，关闭！没啥用

环绕快捷键：command+option+T

主动抛出异常。在方法头写，一般是throws，在方法内，一般是throw

if(b=0){throw new AritmeticException();//主动的抛出异常
}public void test(int a,int b) throws throws ArithmeticException{}

JAVA SE基础---kuangstudy相关推荐

java实现linkstring,【JAVA SE基础篇】32.String类入门
[JAVA SE基础篇]32.String类入门 1.字符串 1.String类又称作不可变字符序列 2.String位于java.lang包中,java程序默认导入java.lang包下所有的类 3 ...
面试必会系列 - 1.1 Java SE 基础
本文已收录至 github,完整图文:https://github.com/HanquanHq/MD-Notes Java SE 基础面向对象 Java 按值调用还是引用调用? 按值调用指方法接收调 ...
java 中间容器表格_【JAVA SE基础篇】45.迭代器、Collections工具类以及使用容器存储表格...
本文将要为您介绍的是[JAVA SE基础篇]45.迭代器.Collections工具类以及使用容器存储表格,具体完成步骤: 1.迭代器迭代器为我们提供了统一遍历容器(List/Map/Set)的方式 ...
Java复习总结（二）Java SE基础知识
Java SE面试题目录 Java SE基础基本语法数据类型关键字面向对象集合集合类概述 Collection接口进阶线程锁 JDK 反射 JVM GC io操作和NIO,AIO ...
Java SE基础（十六）集合
Java SE基础(十六)集合集合集合体系数据结构简述栈队列数组链表 Collection集合 List集合 ArrayList集合 LinkedList集合 Set集合 HashSet ...
Java SE 基础知识
Java SE 基础知识 1 2 @(Notes)[J2SE, Notes] VICTORY LOVES PREPARATION. 特别说明: 该文档在马克飞象查阅最佳: 本部分知识还在迭代中,欢迎补 ...
Java SE基础(更新中)
Java的运行机制 Java SE基础(更新中) 基本语法大小写敏感:Java 是大小写敏感的,这就意味着标识符 Hello 与 hello 是不同的. 类名:对于所有的类来说,类名的首字母应该大写 ...
Java SE 基础（十）Java中的异常
Java SE 基础(十)Java中的异常什么是异常异常的处理异常类 throw和throws 自定义异常什么是异常 Java 中处理错误的一种机制,Java 中的错误大致分为两类,一类是编译 ...
Java SE基础（十四）常用API
Java SE基础(十四)常用API 概述 Object类构造方法成员方法 toString()方法 equals(Object obj)方法 Arrays排序 Arrays类概述 Arrays成 ...
Java SE 基础知识体系梳理
## Java SE 基础知识体系梳理 ----------day01------------- (1)计算机的体系结构 (2)Java语言的概述 (3)开发环境的搭建和使用 1.计算机的体系结构(常 ...

JAVA SE基础---kuangstudy