JavaBase

1、访问修饰符

public： 可修饰当前类、同一包中、子孙类（同一包）、子孙类（不同包）对所有类可见。使用对象：类、接口、变量、方法。

protected: 可修饰当前类、同一包中、子孙类（同一包）对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

private：可修饰当前类、 在同一类内可见。使用对象：变量、方法。

2、Java基础语法

对象：对象是类的一个实例，有状态和行为。例如，一只猫是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、睡觉、吃等。

类：类是一个模板，它描述一类对象的行为和状态。

方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。

实例变量:每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定。

3、变量

局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁，访问修饰符不能用于局部变量、局部变量没有默认初始化值，所以局部变量被声明后，必须经过初始化，才可以使用。

成员变量:成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问，成员变量有默认初始化值。

类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型。

Java内存结构

Java 内存分为堆内存和栈内存，还有方法区（jdk1.8元空间）

堆内存：存放Java的对象（成员变量new的）

栈内存：存放局部变量（int a; int b; 等）

方法区：存放静态资源，方法，类等信息

4、数组

一、概念

数组是存储数据长度固定的容器，存储多个数据的数据类型一致。

数组中的元素是从0开始编号的。

二、数组定义类型

（1）、格式一

元素类型[] 数组名 = new 元素类型[元素个数或数组长度]；

int[] arr = new int[5];

（2）、格式二

元素类型[] 数组名 = new 元素类型[]{元素1，元素2，....};

int[] arr = new int[]{3,5,1,7};

int[] arr = {3,5,1,7};

三、数组遍历

public static void main(String[] args) {
​
int[] x = { 1, 2, 3 };
​
for (int y = 0; y < x.length; y++) {
​
System.out.println(x[y]);
​
System.out.println("x["+y+"]="+x[y]); 打印效果 x[0]=1;
​
} 
// 那么这就是数组的第一个常见操作.遍历
}

原文链接：java数组详解_oguro的博客-CSDN博客_java数组

四、数组的常见异常

NullPointerException // 空指针异常
ArrayIndexOutOfBoundsException //索引值越界

五、冒泡排序

public class Sort {
    //冒泡排序
    public static void main(String[] args) {
        int[] arr = new int[]{3,2,9,1,5,7};
        int team;
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j <arr.length-i-1; j++) {
                if(arr[j] > arr[j+1]) {
                    team = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = team;
                }
            }
            }
        for (int i = 0; i < arr.length; i++) {
            int i1 = arr[i];
            System.out.println(i1);
        }
        }
​
    }

六、数组删除

//删除
public void delete(int id){
    Integer newindex = null;
    for (int i = 0; i < stuDate.length; i++) {
        Student student = stuDate[i];
        //挪移删除之后的数据
        if(newindex != null && student != null){
          stuDate[newindex] = stuDate[i];
          stuDate[i] = null;
          newindex++;
        }
        //具体的删除方法
         if (student != null && student.getId() == id){
             stuDate[i] = null;
             index--;
             newindex = i;
         }
    }
}

5、运算符

一、算术运算符

+加 -减 *乘 /除 %取余 ++自增 --自减

前缀自增自减法(++a,--a): 先进行自增或者自减运算，再进行表达式运算。

后缀自增自减法(a++,a--): 先进行表达式运算，再进行自增或者自减运算 实例：

public class selfAddMinus{    public static void main(String[] args){       
int a = 5;//定义一个变量；       
int b = 5;        
int x = 2*++a;        
int y = 2*b++;        
System.out.println("自增运算符前缀运算后a="+a+",x="+x);      
System.out.println("自增运算符后缀运算后b="+b+",y="+y);    
}
}
//运行结果为：
//自增运算符前缀运算后a=6，x=12
//自增运算符后缀运算后b=6，y=10

二、关系运算符

== 判断值是否相等 != 判断值是否不相等 >大于 < 小于 >=大于等于 <= 小于等于

三、逻辑运算符

&& 当且仅当两个操作数都为真，条件才为真。

|| 如果任何两个操作数任何一个为真，条件为真。

! 称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。否定名句

6、Java 循环结构-for，while 及 do...while

一、while循环

while是最基本的循环，它的结构为：

while( 布尔表达式 ) { 
   //循环内容
}
//只要布尔表达式为 true，循环就会一直执行下去
//布尔表达式就是判断语句 例如 a<10;
​
//实例
public class Test {
   public static void main(String args[]) {
      int x = 10;
      while( x < 20 ) {
         System.out.print("value of x : " + x );
         x++;
         System.out.print("\n");
      }
   }
}

二、do...while循环

对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。

do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。

布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了。 如果布尔表达式的值为 true，则语句块一直执行，直到布尔表达式的值为 false。

//代码格式
do {
       //代码语句
}while(布尔表达式);

三、for循环

//代码格式
for(初始化; 布尔表达式; 更新) {
//代码语句 
}
//实例
public class Test {
   public static void main(String args[]) {
 
      for(int x = 10; x < 20; x = x+1) {
         System.out.print("value of x : " + x );
         System.out.print("\n");
      }
   }
}
//Java增强for循环 用于数组
for(声明语句 : 表达式)
{
   //代码句子
}
//实例
public class Test {
   public static void main(String args[]){
      int [] numbers = {10, 20, 30, 40, 50};
 
      for(int x : numbers ){
         System.out.print( x );
         System.out.print(",");
      }
      System.out.print("\n");
      String [] names ={"James", "Larry", "Tom", "Lacy"};
      for( String name : names ) {
         System.out.print( name );
         System.out.print(",");
      }
   }
}

四、break关键字

break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。

break 跳出最里层的循环，并且继续执行该循环下面的语句。

public class Test {   public static void main(String args[]) {     
    int [] numbers = {10, 20, 30, 40, 50};       
    for(int x : numbers ) {        
        // x 等于 30 时跳出循环        
        if( x == 30 ) {    
            break;       
        }         
        System.out.print( x );        
        System.out.print("\n");     
    } 
} 
}
//运行结果:10,20

五、continue关键字

continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。

public class Test {   public static void main(String args[]) {     
    int [] numbers = {10, 20, 30, 40, 50};      
    for(int x : numbers ) {     
        if( x == 30 ) {     
            continue;      
        }        
        System.out.print( x );       
        System.out.print("\n");   
    }  
}
}
//运行结果:10,20, 40, 50

7、面向对象 Java继承

一、继承就是子类继承父类的方法和属性，代码更加简洁，提高代码的复用性

//狗类
public class Dog {
    private String color;
    private String name;
    private int price;
    private int age;
​
    public Dog(String color, String name, int price, int age) {
        this.color = color;
        this.name = name;
        this.price = price;
        this.age = age;
    }
    public void eat(){
        System.out.println(name+"正在吃");
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() {
        System.out.println("狗{" +
                "颜色：'" + color + '\'' +
                ", 品种：'" + name + '\'' +
                ", 价格=" + price +
                ", 年龄=" + age +
                '}');
    }
}

//公共父类
public class Common {
    private String color;
    private String name;
    private int price;
    private int age;
​
    public Common(String color, String name, int price, int age) {
        this.color = color;
        this.name = name;
        this.price = price;
        this.age = age;
    }
    public void eat(){
        System.out.println(name+"正在吃");
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() {
        System.out.println("狗{" +
                "颜色：'" + color + '\'' +
                ", 品种：'" + name + '\'' +
                ", 价格:=" + price +
                ", 年龄:=" + age +
                '}');
    }
}

//猫类继承父类的方法和属性
public class Cat extends Common{
​
    public Cat(String color, String name, int price, int age){
        super(color,name,price,age);
    }
}

二、继承类型：

需要注意的是 Java 不支持多继承，但支持多重继承。

三、继承的特性

子类拥有父类非private的属性、方法。

子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

（相当于创新，子类是个独立的个体，父类是个固定的库，是所有共性的东西）

子类可以用自己的方式实现父类的方法。

提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

四、继承关键字

（1）extends 关键字

extends 只能继承一个类

（2）implements关键字

implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

五、super与this关键字

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

super可用于：

this关键字：指向自己的引用。

this关键字可用于

（1） 调用父类的构造方法；

super();  
​
或   
​
super(参数列表);

（2）调用父类的方法（子类覆盖了父类的方法时）；

super.方法名(参数列表);

（1）调用当前类的构造方法，并且必须是方法的第一条语句。如：this(); 调用默认构造方法。this(参数); 调用带参构造方法。

（2）限定当前对象的数据域变量。一般用于方法内的局部变量与对象的数据域变量同名的情况。如 this.num = num。this.num 表示当前对象的数据域变量 num，而 num 表示方法中的局部变量。

六、final关键字

final关键字声明类可以把类定义为不能继承的，即最终类，修饰的方法不能被重写，修饰的变量不能被修改

七、构造器

子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。

如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。