常见的基础内容:
Java 的命名规范:
Java是大小写敏感的,这就意味着标识符Hello与hello是不同的
java的变量命名规范:首字母:英文字母、$和下划线。变量名:由$、字母、数字和下划线组成。
类名:单个单词,首字母大写,多个单词,首字母都大写。
方法名、参数名、变量名:单个单词,首字母小写,多个单词,第一单词首字母小写,其他单词首字母大写。
包名:全部小写。
java的修饰符:
非访问控制修饰符 : final, abstract, static, synchronized
访问控制修饰符 : default, public , protected, private
java语言的变量类型:【全局变量是有默认值的,int类型默认值为0,string类型默认为null,局部变量必须要进行初始化】
1、类变量:独立与方法之外的变量,用static进行修饰
2、实例变量:独立于方法之外的变量,不过没有static进行修饰
3、局部变量:类的方法中的变量,局部变量必须要进行初始化
public class Variable{
static int allClicks=0; // 类变量 ,全局变量
String str="hello world"; // 实例变量
public void method(){
int i =0; // 局部变量
}
}
java枚举:【枚举可以单独声明或者声明在类里面。方法、变量、构造函数也可以在枚举中定义。使用枚举可以减少代码中的 bug。】
class FreshJuice {
enum FreshJuiceSize{ SMALL, MEDIUM , LARGE }
FreshJuiceSize size;
}
public class FreshJuiceTest {
public static void main(String []args){
FreshJuice juice = new FreshJuice();
juice.size = FreshJuice.FreshJuiceSize.MEDIUM ;
}
}
Java的do,while循环【首先就是会进行do里面的内容的执行,然后在判断while的内容是不是符合规定,如果里面的条件是符合规定的,再次执行do里面的内容,直到不满足条件】
public class StringBase {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int a=sc.nextInt();
do {
System.out.println(a);
a++;
}
while (a<=10);
System.out.println("结束");
}
}
while循环就是判断是不是满足while里面的内容,如果满足的执行while里面的循环体,如果不满足,就直接跳出
public class StringBase {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int a=sc.nextInt();
while (a<=10){
System.out.println(a);
a++;
}
System.out.println("结束");
}
}
instanceof(实例)【instanceof 严格来说是Java中的一个双目运算符,用来测试一个对象是否为一个类的实例,用法为:】
https://www.cnblogs.com/ysocean/p/8486500.html
boolean result = obj instanceof Class
其中 obj 为一个对象,Class 表示一个类或者一个接口,当 obj 为 Class 的对象,或者是其直接或间接子类,或者是其接口的实现类,结果result 都返回 true,否则返回false。
throw和throws的区别
1、throws出现在方法函数头;而throw出现在函数体。
2、throws表示出现异常的一种可能性,并不一定会发生这些异常;throw则是抛出了异常,执行throw则一定抛出了某种异常。
3、两者都是消极处理异常的方式(这里的消极并不是说这种方式不好),只是抛出或者可能抛出异常,但是不会由函数去处理异常,真正的处理异常由函数的上层调用处理。
Java虚拟机
java虚拟机实际上只是一层接口,一层Java程序和操作系统通讯的接口。java文件编译生成class文件,
而java虚拟机就是这些class文件能够在上面运行的一个平台,你把class文件看成一个软件,java虚拟机就是这个软件可以运行的操作系统。
解释运行字节码程序(Java程序编译后产生)、消除平台差异性
使用Java虚拟机是实现这一特点的关键 一般的高级语言如果要在不同的平台上运行 至少需要编译成不同的目标代码 而引入Java语言虚拟机后 Java语言在不同平台上运行时不需要重新编译 Java语言使用模式Java虚拟机屏蔽了与具体平台相关的信息 使得Java语言编译程序只需生成在Java虚拟机上运行的目标代码(字节码)就可以在多种平台上不加修改地运行 Java虚拟机在执行字节码时 把字节码解释成具体平台上的机器指令执行
Java应用的特点
1、一个源文件中只能有一个public修饰的类,其他类个数不限。
2、一个源文件有n个类时,编译结果的class文件就有n个。
3、源文件的名字必须和public修饰的类名相同
4、java语言中单词拼写大小写严格区分。
5、main方法入口
6、每一句以分号(;)结束
Java类中方法的调用【在一个源文件中,只能有一个public修饰的类,并且在类中定义的 static方法,可以直接进行方法名的调用】
class test{
public static void test4(){
System.out.println("test4");
}
public void test1(){
test4();//可以直接进行调用的
System.out.println("test1");
}
}
public class StringBase {
public void test2(){
System.out.println("test2");
}
public static void test3(){
System.out.println("test3");
}
public static void main(String[] args) {
test.test4();//静态方法可以直接用类名.方法名直接调用
test test=new test();
test.test1();//要定义类的对象,对象调用类里面的方法
StringBase sb=new StringBase();
sb.test2();
test3();//可以直接进行调用
}
}
执行结果:
test4
test4
test1
test2
test3
Java的单引号和双引号的区别:
单引号引的数据 是char类型的——》单引号只能引一个字符(表示单个字符)
双引号引的数据 是String类型的——》而双引号可以引0个及其以上(引用字符串)
首先单引号引起来的都是单字符例如:char a='a';这样是可以使用的,但是如果String a=‘a’ 和String a='aa' 这样就是会报错的,超过一位的字符就要使用String
三目运算符:X ? Y : Z
min=(a
程序的流程控制
结构化程序的三种结构:顺序、选择(分支)、循环
switch的选择分支结构:
switch (a){
case 2:
System.out.println(3);
break;//加上break会跳出本次的switch选择结构
case 3:
System.out.println(3);
}
递归的特征:
函数有返回值类型、函数有参数、函数中有跳出循环的控制语句、自己调用自己
java的静态(static)
在静态的情况下:可以使用 类名.方法名 类名.属性名 这样的方式直接进行调用对应的属性或者是方法名.
也可以进行对象的创建,然后用对象进行属性或者是方法名的调用;
public class StringBase {
static int a;//全局变量,类变量,初始默认值是0
public static void test3(){
String test="test";
System.out.println("test3");
}
public static void main(String[] args) {
System.out.println(StringBase.a);
StringBase.test3();
StringBase sb =new StringBase();
System.out.println(sb.a);
sb.test3();
}
}
在非静态的情况下,只能使用对象进行相应的调用
java中的this的使用
【在类的构造器中使用,并且this后面调用的全是本类中的资源(变量,方法{普通函数:this.test1();有参构造this(int n);无参构造this();})】
1、在有参构造中的使用,构造函数的默认类型是public
class Person{
private String name;
private int age;
public Person(String name,int age) {
this.name = name; //this.name明确表示调用类中name属性就近原则,不再使用
this.age = age;
}
public void getpersonInfo(){
System.out.println("姓名:"+name+",年龄:"+age);
}
}
public class ThisTest {
public static void main(String[] args){
Person per=new Person("张二",25);
per.getpersonInfo();
}
}
执行结果:姓名:张二,年龄:25
2、可以调用类中的方法
public class ThisTest {
private String name;
private int age;
public ThisTest(String name,int age) {
this.name = name;
this.age = age;//this.age表示本类属性
this.print("#############");//调用普通方法
}
public void print(String n){
System.out.println(n);
}
public String getpersonInfo(){
return "姓名:"+name+",年龄:"+age;
}
public static void main(String[] args){
ThisTest per=new ThisTest("张三",30);
System.out.print (per.getpersonInfo());
}
}
执行结果:
#############
姓名:张三,年龄:30
3、调用类中的构造方法(有参构造方法/无参构造方法)
public class ThisTest {
private String name;
private int age;
public ThisTest() {
System.out.println("***产生一个新的person对象***");
}
public ThisTest(String name) {
this();//调用本类中无参构造
this.name=name;
}
public ThisTest(String name,int age) {
this(name);//调用本类有参构造
this.age=age;
}
public String getpersonInfo(){
return "姓名:"+name+",年龄:"+age;
}
public static void main(String[] args){
ThisTest per1=new ThisTest();
System.out.println (per1.getpersonInfo());
ThisTest per2=new ThisTest("张二");
System.out.println (per2.getpersonInfo());
ThisTest per3=new ThisTest("张三",30);
System.out.println (per3.getpersonInfo());
}
}
执行结果:
***产生一个新的person对象***
姓名:null,年龄:0
***产生一个新的person对象***
姓名:张二,年龄:0
***产生一个新的person对象***
姓名:张三,年龄:30
java的super的使用
super是调用父类里面的资源(变量和类,this是调用本类中的资源和方法)
java初始化顺序。初始化子类必先初始化父类。子类的构造方法会隐式去调用 父类无参的构造方法(不会在代码中显示)。但如果父类没有无参的构造方法,就必须在子类构造方法第一行显示调用父类的有参构造方法。否则编译失败
1、子类继承父类的时候,会自动调用父类的无参构造器
class Person{
Person(){//无参构造器
System.out.println("person");
}
}
public class ThisTest extends Person{
ThisTest(){
System.out.println("ThisTest");
}
public static void main(String[] args){
ThisTest tt=new ThisTest();
}
}
执行结果:
person
ThisTest
2、子类调用父类的方法和属性【子类没有进行初始化,则父类的初始化也不会有要求,只有在子类进行构造器初始化的时候,才会涉及到父类里面的初始化】
class Country {
String name;
void value() {
System.out.println("china");
name = "China";
}
}
class ThisTest extends Country {
String name;
void value() {
name = "Hefei";
super.value();//不调用此方法时,super.name返回的是父类的成员变量的值null
System.out.println(name);
System.out.println(super.name);
}
public static void main(String[] args) {
ThisTest c=new ThisTest();
c.value();
}
}
执行结果:
china
Hefei
China
3、子类调用父类中的构造方法(在子类中不写super的情况下,默认会调用父类的无参构造器,如果super中传入参数的话,会调用父类中对应的有参构造)
class Person {
public static void prt(String s) {
System.out.println(s);
}
Person() {
prt("A Person.");
}
Person(String name) {
prt("A person name is:" + name);
}
}
public class ThisTest extends Person {
ThisTest() {
super(); // 调用父类构造函数(1)
prt("A chinese.");// (4)
}
ThisTest(String name) {
super(name);// 调用父类具有相同形参的构造函数(2)
prt("his name is:" + name);
}
ThisTest(String name, int age) {
this(name);// 调用当前具有相同形参的构造函数(3)
prt("his age is:" + age);
}
public static void main(String[] args) {
ThisTest cn = new ThisTest();
cn = new ThisTest("kevin");
cn = new ThisTest("kevin", 22);
}
}
执行结果:
A Person.
A chinese.
A person name is:kevin
his name is:kevin
A person name is:kevin
his name is:kevin
his age is:22
java的final关键字
1、final可以修饰全局变量,并且在进行变量创建的时候,必须要进行初始化;也可以修局部变量,但是也必须要进行初始化赋值
static final int a=0;
2、final修饰方法,对final修饰的方法,用子类继承父类时候,是不可以进行重写的
class Animal {
public final void move() {//用final进行修饰方法时候,子类是无法进行重写父类方法的
System.out.println("动物可以动");
}
}
class Dog extends Animal {
public void move() {
System.out.println("狗可以跑和走");
}
}
public class ThisTest {
public static void main(String[] args) {
Animal a = new Animal(); // Animal 对象
Animal b = new Dog(); // Dog 对象,由父类创建的子类对象
a.move();// 执行 Animal 类的方法
b.move();//执行 Dog 类的方法
}
}
执行结果:报错:
Error:(9, 17) java: com.zch.springboot_mybatis.Dog中的move()无法覆盖com.zch.springboot_mybatis.Animal中的move()
被覆盖的方法为final
3、final修饰类,则此类无法在进行继承
final class Animal {
public void move() {//用final进行修饰方法时候,子类是无法进行重写父类方法的
System.out.println("动物可以动");
}
}
class Dog extends Animal {
public void move() {
System.out.println("狗可以跑和走");
}
}
public class ThisTest {
public static void main(String[] args) {
Animal a = new Animal(); // Animal 对象
Animal b = new Dog(); // Dog 对象,由父类创建的子类对象
a.move();// 执行 Animal 类的方法
b.move();//执行 Dog 类的方法
}
}
执行结果:
报错:Error:(8, 19) java: 无法从最终com.zch.springboot_mybatis.Animal进行继承
java面向对象的三大特性
1、封装(可以提高代码的的安全性):
将属性进行私有化,并且提供对外界的接口(get/set方法)
用private进行修饰属性和方法,并且只能在本类中进行使用
2、继承(可以提高代码的复用性,减少重复代码)
子类可以继承父类的非私有的属性和方法,但是不可以继承父类的构造方法以及私有属性和方法
子类在继承父类的元素的时候,也可以进行修改(重写)
一个子类只能继承一个父类,必须是单继承
子类可以通过使用super进行参数的传递,进行父类的有参构造器的初始化
3、多态性:
运行时多态性:重写(子类继承父类的方法进行重写,但是子类方法的访问类型要大于父类的访问类型)
编译时多态性:重载(重载就是同名方法的不同参数)
java的抽象类(用abstract进行修饰的类)
1、如果一个类里面有抽象方法,那么这个类必须定义为抽象的;
2、抽象类是不能进行创建对象的,因为抽象类不能进行实例化
3、继承抽象类,使用的关键字是extends
Java的接口(interface)
1、实现接口用implements关键字
2、接口中只有全局变量和抽象方法
3、接口在实现的时候,同时去继承,extends在implements前面
Java排序算法:
1、冒泡排序
public class MaoPao {
public static void main(String []args ){
int a[]={1,3,4,5,2,7,6,10,9,8};
for(int i=0;i
for(int j=0;j
if(a[j]>a[j+1]){
int temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
}
}
2、选择排序
public class MaoPao {
public static void main(String []args ){
int a[]={1,3,4,5,2,7,6,10,9,8};
for (int i = 0; i < a.length-1; i++) {
int k=i;
for (int j = i; j < a.length-1; j++) {
if (a[k]>a[j+1]) {
k=j+1;
}
}
if(i!=k){
int temp=a[i];
a[i]=a[k];
a[k]=temp;
}
}
for (int i=0; i
System.out.println(a[i]);
}
}
}
Java的StringBuffer用法
String 长度不可变
StringBuffer 长度可变 线程安全 速度慢
StringBuilder 长度可变 线程不安全 速度快
StringBuffer sb=new StringBuffer("a");
System.out.println(sb);
sb.append("b");//追加
System.out.println(sb);
sb.insert(2,"cde");//在指定位置进行插入
System.out.println(sb);
sb.delete(2,3);//在指定位置进行删除
System.out.println(sb);
sb.reverse();//反向逆转
System.out.println(sb);
执行结果:
a
ab
abcde
abde
edba
Java的线程与进程
1、多线程,从宏观的角度看就是同时执行多个进程,在微观的角度看待就是同一时间只能执行一个线程
2、进程是应用程序,线程就是一条执行路径
3、在一个进程中,至少有一个线程
4、开启一个线程,可以继承Thread的类,重写run方法,然后创建类对象,然后对象.start();
class ThreadTest extends Thread{
//继承Thread类,重写run()方法
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"执行Run中");
System.out.println(Thread.currentThread().getName()+"执行完毕");
}
}
public class ExtendThread{
public static void main(String[] args) {
new ThreadTest().start();
new ThreadTest().start();
new ThreadTest().start();
new ThreadTest().start();
new ThreadTest().start();
}
}
还可以通过实现 Runnable接口,重写run方法,创建类对象,然后new Thread(类对象).start 然后通过start来启动多线程
class ThreadTest implements Runnable{
//实现Runnable接口,实现run()方法
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"执行Run中");
System.out.println(Thread.currentThread().getName()+"执行完毕");
}
}
public class ExtendThread{
public static void main(String[] args) {
ThreadTest runnable = new ThreadTest();
new Thread(runnable).start();
new Thread(runnable).start();
new Thread(runnable).start();
new Thread(runnable).start();
new Thread(runnable).start();
}
}
首先run是没有开辟新的栈空间,没有新线程,都是主程序在执行
start开辟了新的栈空间,在新的栈空间里面启动run()方法
tcp和udp
1、tcp:面向连接,数据传输是可靠的,传输效率 偏低,传输数据的大小没有限制
2、udp:面向无连接,数据安全不可靠,执行效率比较高,数据的大小不超过64kb
【tcp和udp只是传输协议,只是设定了规范,真正起到传输作用的是数据ip协议】
【ip协议:将数据从源传递到目的地,ipv4是32位,ipv6是128位】
Java的反射机制
反射就是将Java类中的信息进行拆分,包括属性、方法、构造方法,并且可以进行调用
优点:
1、提高了Java程序的灵活性和拓展性,降低了耦合性,提高了自适应的能力
2、允许程序创建和控制任何类的对象,无需提前编码目标类
get和post的区别:
GET产生一个TCP数据包;POST产生两个TCP数据包。
GET比POST更不安全,因为参数直接暴露在URL上,所以不能用来传递敏感信息。
对参数的数据类型,GET只接受ASCII字符,而POST没有限制。
GET请求会被浏览器主动cache,而POST不会
在类中不能直接进行运算,要写在方法代码块{}或者静态代码块中static{}中
public abstract class MaoPao {
public int constInt = 5;
consInt=constInt+5;
private static void testMethod(){
System.out.println("testMethod");
}
public static void main(String[] args) {
((MaoPao)null).testMethod();
}
}
这样在里面consInt=constInt+5;是会报错的
Java在多线程下的sleep和 wait()
共同点 :
1. 他们都是在多线程的环境下,都可以在程序的调用处阻塞指定的毫秒数,并返回。
2. wait()和sleep()都可以通过interrupt()方法 打断线程的暂停状态 ,从而使线程立刻抛出InterruptedException。
如果线程A希望立即结束线程B,则可以对线程B对应的Thread实例调用interrupt方法。如果此刻线程B正在wait/sleep/join,则线程B会立刻抛出InterruptedException,在catch() {} 中直接return即可安全地结束线程。
需要注意的是,InterruptedException是线程自己从内部抛出的,并不是interrupt()方法抛出的。对某一线程调用 interrupt()时,如果该线程正在执行普通的代码,那么该线程根本就不会抛出InterruptedException。但是,一旦该线程进入到 wait()/sleep()/join()后,就会立刻抛出InterruptedException 。
不同点 :
1.每个对象都有一个锁来控制同步访问。Synchronized关键字可以和对象的锁交互,来实现线程的同步。
sleep方法没有释放锁,而wait方法释放了锁,使得其他线程可以使用同步控制块或者方法。
2.wait,notify和notifyAll只能在同步控制方法或者同步控制块里面使用,而sleep可以在任何地方使用
3.sleep必须捕获异常,而wait,notify和notifyAll不需要捕获异常
4.sleep是线程类(Thread)的方法,导致此线程暂停执行指定时间,给执行机会给其他线程,但是监控状态依然保持,到时后会自动恢复。调用sleep不会释放对象锁。
5.wait是Object类的方法,对此对象调用wait方法导致本线程放弃对象锁,进入等待此对象的等待锁定池,只有针对此对象发出notify方法(或notifyAll)后本线程才进入对象锁定池准备获得对象锁进入运行状态。