Java基础

打开CMD的方式

开始+系统+命令提示符
win键+R 输入cmd打开控制台（推荐使用）
在任意的文件夹下面，按住shift键+鼠标右键点击，在此处打开命令行窗口
资源管理器的地址栏前面加上cmd路径

管理员方式运行：选择以管理员方式运行

常用Dos命令

 #盘符切换
 #查看当前目录下的所有文件  dir
 #切换目录  cd change  directory
 cd..
 #清理屏幕  cls   (clear screen)
 #退出终端  exit
 #查看电脑的ip  ipconfig
 ?
 #打开应用 
     calc
     mspaint
     notepad
 #ping命令
       ping www.baidu.com
 #文件操作
     md  目录名   MD——建立子目录
     rd  目录名   RD——删除子目录命令
     cd> 文件名   CD——改变当前目录
     del 文件名

JDK

卸载JDK

删除Java的安装目录
删除Java_HOM
删除path下关于java的目录
java_version

安装JDK

百度搜多JDK8
同意协议
下载电脑对应的版本
双击安装JDK
记住安装的路径
配置环境变量

1.我的电脑– – >右键– –>属性

2.环境变量– – >JAVA_HOME

3.配置path变量

7.测试JDK是否安装成功

1.打开cmd

2.java -version

notepad++

第一个程序

HelloWord

 public class HelloWord{
   public static void main(String[] args){
     System.out.println("Hello Word!");
   }
 }

注意点：

每个单词的大小写不能出现问题，Java是大小写很敏感的
尽量使用英文；
文件名和类名必须一致，并且首字母大写
符号使用的是中文错误

数据类型拓展：

 //整数拓展    进制    二进制0b     十进制     八进制0      十六进制0x
 ?
 public class HelloWord{
   public static void main(String[] args){
     
     int i = 10;
     int i1 = 010;八进制0
     int i2 = 0x10;十六进制0x  0~9 A~F 16
     
     System.out.println(i);//10
     System.out.println(i1));//8
     System.out.println(i2);//16
   }
 }
 ?
 //浮点数拓展   银行管理  : BigDecimal
 //float     有线  离散  舍入误差  大约  接近但不等于  
 //double
 //最好完全使用浮点数进行比较 ***
 ?
     float f = 0.1f;//0.1
     double d = 1.0/10;//0.1
     
     System.out.println(f==d);//false
     
     float d1 = 321312312;
     float d2 = d1+1;
 ?
     System.out.println(f==d);//true
 ?
 //字符拓展
     char a = 'a';
     char b = '中';
 ?
     System.out.println(a);//a
     System.out.println((int)a);//强制转换  97
 ?
     System.out.println(b);//中
     System.out.println((int)b);//强制转换  20013
 //所有的字符本质还是数字
 //编码  Unicode  2字节  0 - 65536  Excel  2^16 = 65536
 ?
     //U0000  UFFFF
     char c = '\u0061';
     System.out.println(c);//a
 ?
 //转义字符
 //  \t  制表符
 //  \n  换行
 System.out.println("Hello\tWord");
 ?
         String sa = new String("hello word");
         String sb = new String("hello word");
 ?
         System.out.println(sa==sb);
 ?
         String sc = "hello word";
         String sd = "hello word";
 ?
         System.out.println(sc==sd);
         //对象  从内存分析
 ?
         //布尔值扩展
         boolean flag = true;
         if (flag==true){}   //新手
         if (flag){}     //老手
         //Less is  More  代码要精简易读

类型转换

 public class Demo {
     public static void main(String[] args) {
         int i =128;
         byte b = (byte) i;//内存溢出
 ?
         //强制转换  (类型)变量名     高->低
 ?
         System.out.println(i);
         System.out.println(b);
         /*
         注意点：
         1.不能对布尔值进行转换
         2.不能把对象类型变为不相干的类型
         3.在把高容量转换为低容量的时候，强制转换
         4.转换的时候可能存在内存溢出，或者精度问题！
          */
 ?
         //操作数比较大的时候，注意溢出问题
         //JDK7新特性，数字之间可以用下划线分割
         int money = 10_0000_0000;
         int years = 20;
         int total = money*years;// -1474836480, 计算的时候溢出了
         int total1 = money*years;//默认是int，转换之前已经存在问题了
 ?
         int total2 = (int) (money*((long)years));//先把一个数转换为Long
         System.out.println(total2);
 ?
 ?
 ?
     }
 }

变量

 public class Demo {
 ?
     //类变量   static
     static double salary = 2500;
     //属性 :变量
 ?
     //实例变量：从属于对象；如果不自进行初始化，这个类型的默认值 0 0.0
     //布尔值：false
     //除了数据类型，其他的默认值都是null
     String name;
     int age;
 ?
     //main方法
     public static void main(String[] args) {
 ?
         //局部变量 ：必须声明和初始化值
         int i = 10;
         System.out.println(i);
 ?
         //变量类型  变量名字 = new Demo();
         Demo demo = new Demo();
         System.out.println(demo.age);
         System.out.println(demo.name);
 ?
         //类变量  static
         System.out.println(salary);
     }
     //其他方法
     public void add(){
 ?
     }
 }

常量：final

 public class Demo {
 ?
     //修饰符，不存在先后顺序
     static final double PI = 3.14;
 ?
     public static void main(String[] args) {
         System.out.println(PI);
     }
 ?
 }

Java变量命名规则为：

1、Java变量命名只能使用字母、数字、下划线、美元符号($)组成。

2、变量名以字母、下划线或者美元符号开头，其中以美元符号开头命名的变量虽然能够编译通过但是不建议使用。

3、变量的名字可大小写混用，但首字符应小写。

4、Java变量名不限制长度，在命名的时候，尽量使用完整的单词进行命名，不要使用缩写。

5、变量名不可以和java关键字冲突，但是可以包含关键字。

运算符优先级：（）

：long以下的都会为int，long以上的都为最高那个

一元运算符

 public class Demo {
 ?
     public static void main(String[] args) {
 ?
         //++  --    自增，自减  一元运算符
         int a = 3;
 ?
         int b = a++;//执行完这行代码后，先给b赋值，在自增
         //a = a+1;
         System.out.println(a);
         //a = a+1;
 ?
         int c = ++a;//执行完这行代码后，先自增,再给b赋值
 ?
 ?
         //幂运算 2^3  2*2*2 =8 很多运算，我们会使用一些工具类来操作！
 ?
         double pow = Math.pow(3, 2);
         System.out.println(pow);
     }
 ?
 }

位运算符

 public class Demo {
 ?
     public static void main(String[] args) {
 ?
         /*
         A = 0011 1100
         B = 0000 1101
         -----------------
         A&B = 0000 1100
         A|B = 0011 1101
         A^B = 0011 0001
         ~B = 1111 0010
 ?
         2 * 8 = 16   2*2*2*2
         效率极高！！！
         <<      *2
         >>      /2
 ?
         0000 0000   0
         0000 0001   1
         0000 0010   2
         0000 0011   3
         0000 0100   4
         0000 1000   8
         0001 0000   16
          */
         System.out.println(2<<3);
     }
 ?
 }

赋值运算符

 public class Demo {
 ?
     public static void main(String[] args) {
         int a = 10;
         int b = 20;
         a+=b;//a=a+b
         a-=b;//a=a-b
 ?
         System.out.println(a);
         //字符串连接符    + ，String
         System.out.println(""+a+b);//1020
         System.out.println(a+b+"");//30
     }
 ?
 }

条件运算符

 public class Demo {
     
     public static void main(String[] args) {
         //x ? y : z
         //如果x==true，则结果为y，否则为z
 ?
         int score = 80;
         String type = score < 60 ?"不及格":"及格";
         System.out.println(type);
     }
 }

包机制

包机制：一般利用公司域名倒置作为包名；

JavaDoc

命令：javadoc -encoding UTF-8 -charset UTF-8 Doc.java

可以直接写成：javadoc Doc.java

Scanner：用户交互

next( ):

一定要读取到有效字符后才可以结束输入
对输入有效字符之前遇到的空白，next()方法会自动将其去掉
只有输入有效字符后才将其后面的空白作为分隔符或者结束符
next()不能得到带有空格的字符串

nextLine():

以Enter为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符
可以获得空白

实例：

 public class Demo {
 ?
     public static void main(String[] args) {
 ?
         //创建一个扫描器对象，用于接收键盘数据
         Scanner scanner = new Scanner(System.in);
         System.out.println("使用next方式接收:");
 ?
         //判断用户有没有输入字符串
         if (scanner.hasNext()){
             String next = scanner.next();//程序会等待用户输入完毕
             System.out.println("输入的内容为："+next);//hello
         }
         //凡是属于IO流的类如果不关闭会一直占用资源，要养成好习惯用完就关
         scanner.close();
     }
 }

 public class Demo {
 ?
     public static void main(String[] args) {
 ?
         //接收键盘数据
         Scanner scanner = new Scanner(System.in);
         System.out.println("使用nextLine方式接收:");
 ?
         //判断是否还有输入
         if (scanner.hasNextLine()){
             String next = scanner.nextLine();//程序会等待用户输入完毕
             System.out.println("输入的内容为："+next);//hello word
         }
         scanner.close();
     }
 }

Scanner进阶：

 public class Demo {
 ?
     public static void main(String[] args) {
         //我们可以输入多个数字，并求其和与平均值，每输入一个数字就回车确认，通过输入非数字  来结束输入并输出结果
         Scanner scanner = new Scanner(System.in);
 ?
         //和
         double sum = 0;
         //计算输入了多少个数字
         int m = 0;
 ?
         //通过循环判断是否还有输入，并在里面每一次进行求和统计
         while(scanner.hasNextDouble()){
             double x = scanner.nextDouble();
             m++;
             sum += x;
             System.out.println("你输入了第"+m+"个数据，然后当前的结果sum="+sum);
         }
         System.out.println(m+"个数的和为"+sum);
         System.out.println(m+"个数的平均值是"+(sum/m));
 ?
         scanner.close();
     }
 }

循环

if

 public class Demo {
 ?
     public static void main(String[] args) { 
       if(表达式){
         A:如果表达式的值是真的，就会执行语句A，否则不执行
       }
     }
 }

switch

switch循环

使用方法：一般用来做分支的，或者进行选择

 public class Demo {
 ?
     public static void main(String[] args) {
         String name = "秦疆";
         switch (name){
             case "秦疆":
                 System.out.println("秦疆");
                 break;
             case "狂神":
                 System.out.println("狂神");
                 break;
         }
     }
 }

while

while循环

使用方法：先判断，在执行；当条件表达式成立时，则执行循环体，然后在进行判断，如果条件不成立时，有可能不执行。一般用于循环次数不确定的循环

 int i=0;
   int sum=0;
   while (i<100){
   if (i%3==0) {
    sum+=i;
            }
    i++;
  }
   System.out.println("100以内的能被3整除之数的和为"+sum);

do-while

do..while循环

使用方法：先执行，后判断；一般用于循环次数不确定的循环，与while循环不同的是先执行后判断，至少会执行一次。

 int j=1;
   int sum2=0;
   do {
    if (j%5==0&&(j%7==0)) 
     sum2 +=j;
     j++;
   } while (j<=100);
   
   System.out.println("100以内即能被5整除又能被7整除数的和"+sum2);

for

for循环（已知循环多少次）

使用方法：先判断，在执行；如果循环次数确定，那么一般用for循环

for循环是最有效，最灵活的循环结构

 int sum=0;
  
    for (int i = 0; i < 100; i++) {
 sum +=i+1;
        }
     System.out.println("100以内的和为:"+sum);

break

：用于强制退出循环

continue

：用于终止某次循环过程

goto关键字

 public class Demo {
 ?
     public static void main(String[] args) {
 ?
         //打印101-105之间所有的质数
         //质数是指在大于1的自然数中，除了1和他本身不会再有其他因数的自然数
         //不建议使用！了解即可的一个玩法
         int count = 0;
         outer:for (int i = 101; i < 150; i++) {
             for (int j = 2; j < i/2; j++) {
                 if (i % j==0){
                     continue outer;
                 }
             }
             System.out.println(i+"");
         }
     }
 }

方法

重载(overloading)：是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

方法重载的规则：

方法名称必须相同
参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）
方法的返回类型可以相同也可以不同
仅仅返回类型不同不足以成为方法的重载
方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器会报错

重写：是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

可变参数

JDK1.5开始，Java支持传递同类型的可变参数给一个方法
在方法声明中，在指定参数类型后加一个省略号(…)
一个方法中只能指定一个可变参数，他必须是方法的最后一个参数。任何普通的参数必须在他之前声明

实例：

 public class Demo {
 ?
     public static void main(String[] args) {
         printMax(12,43,65,232,22);
         printMax(new double[]{1,2,3,4,5});
 ?
     }
     public static void printMax(double... numbers){
 ?
         if (numbers.length==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 = numbers[i];
             }
         }
         System.out.println("The Max value is"+result);
     }
 }

递归

：简单来说就是自己调用自己

递归结构包括两部分：

递归头：什么时候不调用自生方法。如果没有头，将陷入死循环。

递归体：什么时候需要调用自身方法。

实例：看代码

 //递归
 public class Demo {
 //递归思想
     //阶乘
     //5! 5*4*3*2*1
     public static void main(String[] args) {
         System.out.println(f(5));
     }
     public static int f(int n){
         if (n==1){
             return 1;
         }else {
             return n *f(n-1);
         }
     }
 }

数组(Array):

 public class Demo {
 ?
         //变量的类型     变量的名字   =   变量的值
         //数组类型
         public static void main(String[] args) {
             int[] nums ;//1.声明一个数组
             nums = new int[3];//创建一个数组
 ?
             //3.给数组元素中赋值    数组下标从0开始
             nums[0]=1;
             nums[1]=2;
             nums[2]=3;
 ?
             int sum = 0;//计算所有元素的和
 ?
             //获得数组长度： array.length
             for (int i = 0; i < nums.length; i++) {
                 sum = sum +nums[i];
             }
             System.out.println("总和为："+sum);
         }
 ?
 }

数组初始化：

 public class Demo {
 ?
     public static void main(String[] args) {
         //静态初始化 ：创建 + 赋值
         int[] a = {1,2,3,4};
         System.out.println(a[1]);
 ?
         //动态初始化
         int[] b = new int[10];
         b[2] = 10;
         System.out.println(b[2]);
         System.out.println(b[3]);//     0 默认值
         //System.out.println(b[10]);   // ArrayIndexOutOfBoundsException  : 数组下标越界异常
 ?
     }
 }

数组的四个基本特点：

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

数组总结：

数组是相同数据类型（数据类型可以为任意类型）的有序集合
数组也是对象。数组元素相当于对象的成员变量
数组长度是确定的。不可变的。如果越界，则报：ArrayIndexOutOfBoundsException

进阶方法：

 public class Demo {
 ?
     public static void main(String[] args) {
         int[] arrays = {1,2,3,4,5};
 //        //JDK1.5,没有下标
 //        for (int array : arrays) {
 //            System.out.println(array);
 //        }
         int[] reverse = reverse(arrays);
         printArray(reverse);
 ?
     }
     public static int[] reverse(int[] arrays){
         int[] result =  new int[arrays.length];
 ?
         //反转的操作
         for (int i = 0,j= result.length-1; i < arrays.length; i++,j--) {
             result[j] = arrays[i];
         }
         return result;
     }
     //打印数组元素
     public static void printArray(int[] arrays){
         for (int i = 0; i < arrays.length; i++) {
             System.out.print(arrays[i]+" ");
         }
     }
 }

二维数组：

 public class Demo {
 ?
     public static void main(String[] args) {
         //[4][2]
         /*
         1,2     array[0]
         2,3     array[1]
         3,4     array[2]
         4,5     array[3]
          */
         int[][] array = {{1,2},{2,3},{3,4},{4,5}};
         for (int i = 0; i < array.length; i++) {
             for (int j = 0; j < array[i].length; j++) {
                 System.out.println(array[i][j]);
             }
         }
         printArray(array[0]);
     }
     
     //打印数组元素
     public static void printArray(int[] arrays){
         for (int i = 0; i < arrays.length; i++) {
             System.out.print(arrays[i]+" ");
         }
     }
 }

Arrays类:

 public class Demo {
 ?
     public static void main(String[] args) {
 ?
         int[] a = {1, 4, 3, 6, 7};
         //打印数组元素    Arrays.toString()
         System.out.println(Arrays.toString(a));
 ?
         Arrays.sort(a);//对数组进行排序
         System.out.println(Arrays.toString(a));
 ?
         //填充   formIndex: 起始下标 toIndex: 结束下标
         Arrays.fill(a,2,4,0);
         System.out.println(Arrays.toString(a));
     }
 ?
     //打印数组元素
     public static void printArray(int[] a){
         for (int i = 0; i < a.length; i++) {
             System.out.print(a[i]+" ");
         }

冒泡排序

时间复杂度：O(n2)

思路：

这里可以理解为如果有两杯子水一杯水是红色（A）的一杯水是蓝色（B）的，我们要交换这两杯水，这个时候我们就需要一个容器temp，我们要把A先导入容器中然后把B导入A,接着把容器中的水导入B。

 public class Demo {
 ?
     //1.比较数组中，两个相邻的元素，如果选出一个数比第二个数大，就交换他们的位置
     //2.每一次比较，都会产生出一个最大，或者最小的数字；
     //3.下一轮则可以少一次排序
     //4.依次循环直到结束！
 ?
     public static void main(String[] args) {
         int[] a = {1,54,76,34,98,332};
 ?
         int[] sort = sort(a);//调用完我们自己写的排序方法以后，返回一个排序后的数组
         System.out.println(Arrays.toString(sort));
 ?
 ?
     }
     public static int[] 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;
     }
 }

冒泡排序的优化：

为什么要优化？

如果内部排序已经是好的了，可以节约时间成本

     public static int[] sort(int[] array){
         //临时变量
         int temp = 0;
 ?
         //外层循环，判断要循环多少次
         for (int i = 0; i < array.length-1; i++) {
 ?
             boolean flag = false;//通过flag标志位减少没有意义的比较
 ?
             //内层循环，判断两个数，如果第一个数比第二个数大，则交换位置
             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;
                     flag = true;//里面每循环一次flag为true
                 }
             }
             if (flag==false){//说明里面已将是排序好的所以跳出循环
                 break;
             }
 ?
         }
         return array;
     }
 }

稀疏数组

当一个数组中大部分元素为0，或者同一值的数组时，可以使用稀疏数组来保存该数组

稀疏数组的处理方式是：

记录该数组一共有几行几列，有多少个不同值
把具有不同值的元素和行列记录在一个小规模的数组中，从而缩小程序的规模

 public class Demo {
 ?
     public static void main(String[] args) {
         //模拟五子棋
         //1.创建一个二维数组 11 * 11    0：没有棋子  1:黑棋    2：白棋
         int[][] array = new int[11][11];
         array[1][2] = 1;
         array[2][3] = 2;
         //输出原始的数组
         System.out.println("输出原始的数组");
         for (int[] ints : array) {
             for (int anInt : ints) {
                 System.out.print(anInt+"\t");
             }
             System.out.println();
         }
         //转换为稀疏数组
         //获取有效值的个数
         int sum = 0 ;
         for (int i = 0; i < 11; i++) {
             for (int j = 0; j < 11; j++) {
                 if (array[i][j]!=0){
                     sum++;
                 }
             }
         }
         System.out.println("有效值的个数"+sum);
 ?
         int[][] array1 = new int[sum+1][3];//这里的sum+1代表行，有效值的个数加一       3代表列
 ?
         array1[0][0] = 11;//存了多少行
         array1[0][1] = 11;//存了多少列
         array1[0][2] = sum;//几个有效的值
 ?
         //遍历二维数组，将非零的值，存放在稀疏数组中
         int count = 0;
         for (int i = 0; i < array.length; i++) {
             for (int j = 0; j < array[i].length; j++) {
                 if (array[i][j]!=0){
                     count++;
                     array1[count][0] =i;//第几行的第0个数字存他的横坐标
                     array1[count][1] =j;//第几行的第1个数字存他的纵坐标
                     array1[count][2] =array[i][j];//值
                 }
             }
         }
         //输出稀疏数组
         System.out.println("稀疏数组");
 ?
         for (int i = 0; i < array1.length; i++) {
             System.out.println(array1[i][0]+ "\t"
                     +array1[i][1]+ "\t"
                     +array1[i][2]+ "\t");
         }
         System.out.println("==============");
         System.out.println("还原" );
         //1，读取稀疏数组
         int[][] array2 = new int[array1[0][0]][array1[0][1]];
 ?
         //2.给其中的元素还原它的值
         for (int i = 1; i < array1.length; i++) {
             array2[array1[i][0]][array1[i][1]] = array1[i][2];
         }
         //3.打印
         System.out.println("输出还原的数组");
 ?
         for (int[] ints : array2) {
             for (int anInt : ints) {
                 System.out.print(anInt+"\t");
             }
             System.out.println();
         }
     }
 }

面向对象

面向对象编程（Object-Oriented Programming,OOP）
面向对象编程的本质是：以类的方式组织代码，以对象的组织（封装）数据
抽象

三大特性：

封装
继承
多态

关于static他是和类一起加载的而之后的方法是类实例化之后才存在的

看代码

 public class A{
   public static void main(String[] args){
     
   }
   public static  void a(){}//和类一起加载的
   public void b(){}//类实例化之后才存在的
 }

实际参数和形式参数的类型要一一对应

值传递

 //值传递
 public class Demo {
 ?
     public static void main(String[] args) {
         int a = 1;
         System.out.println(a);
         Demo.change(a);
         System.out.println(a);
     }
     public static void change(int a){
         a = 10;
     }
 }

引用传递

 //引用传递：对象，本质还是值传递
 public class Demo {
 ?
     public static void main(String[] args) {
         Person person = new Person();
         System.out.println(person.name);//null
 ?
         Demo.change(person);
         System.out.println(person.name);
 ?
     }
     public static void change(Person person){
         //person是一个对象：指向了--->Person person = new Person();这是一个具体的人，可以改变属性！
         person.name = "秦疆";
     }
 }
 class Person{
     String name;
 }

一个项目只存在一个main方法

super注意点

super调用父类的构造方法，必须在构造方法的第一个
super必须只能出现在子类的方法或者构造方法中！
super 和 this 不能同时调用构造方法！

Vs this：

代表的对象不同：

this：本身调用这个对象
super：代表父类对象的应用
- 前提
this：没有继承也可以使用
super：只能在继承条件下才可以使用
- 构造方法
this():本身的构造
super():父类的构造！

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

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

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

为什么需要重写：

1.父类的功能子类不一定需要，或者不一定满足！

多态注意事项：

多态是方法的多态，属性没有多态
父类和子类，有联系类型转换异常！ ClassCastExpection！
存在条件：继承条件，方法需要重写，父类引用指向子类引用！

static 方法，属于类，他不属于实例
final常量
private方法

类型转换

父类引用指向子类的对象
把子类转换为父类，向上转型
把父类转换为子类，向下转型，强制转换
方便方法的调用，减少重复的代码！简洁

抽象：封装、继承、多态

instanceof：检测某个对象是不是另一个对象的实例

static

 public class Demo {
 ?
     {       //  2   赋初始值
         System.out.println("匿名代码块");
     }
     static {    // 1 只执行一次~
         System.out.println("静态代码块");
     }
 ?
     public Demo() { //  3
         System.out.println("构造方法");
     }
 ?
     public static void main(String[] args) {
         Demo demo = new Demo();
         System.out.println("=====");
         Demo demo1 = new Demo();
     }
 }

还可以静态导入包在import后面加static关键字

抽象类

 //abstract  抽象类：类   extends：单继承~    （接口可以多继承）
 public abstract class Demo {
 ?
     //约束~有人帮我们实现~
     //abstract,抽象方法，只有方法名字，没有方法的实现！
     public abstract void something();
 ?
     //1.不能new这个抽象类，只能靠子类去实现他，约束！
     //2.抽象类可以写普通的方法~
     //3.抽象方法只能在抽象类中~
     //抽象的抽象：约束~
 }

 //抽象类的所有方法，继承了他的子类，都必须要实现他的方法~除非子类也是抽象类
 public class A extends Demo {
     @Override
     public void something() {
 ?
     }
 }

接口

interface定义使用implements实现
接口可以实现多继承
接口中的所有定义的方法其实都是抽象的默认都是： public abstract
常量的定义默认都是：public static final
接口不能被实例化~接口中没有构造方法
必须重写接口中的方法
约束

类Class

一个java类中可以有多个class类，但只能有一个public class

异常

Throwable：这个是最大的异常
Throwable分为Exception与Error
Exception：这是我们的问题可以解决
Error：这是JVM或者底层的一些问题我们不需要管
要捕获多个异常需要从小到大
throw可以主动抛出一个异常
在方法上抛出一个异常就是throws

异常处理

 //自定义的异常类
 public  class MyExpection extends Exception{
 ?
     //传递数字>10
     private int detail;
 ?
     public MyExpection(int a) {
         this.detail = a;
     }
     //tostring：异常信息的打印
 ?
     @Override
     public String toString() {
         return "MyExpection{" +
                 "detail=" + detail +
                 '}';
     }
 }

 public class Test {
 ?
     //可能存在异常的方法
     static void test(int a) throws MyExpection {
         System.out.println("传递的参数为："+a);
         if (a>10){
                 throw new MyExpection(a);//抛出
         }
         System.out.println("ok");
     }
 ?
     public static void main(String[] args) {
         try {
             test(11);
         } catch (MyExpection e) {
             System.out.println("MyExpection=>"+e);
         }
     }
 }

java

Java基础

打开CMD的方式

常用Dos命令

JDK

第一个程序

数据类型拓展：

类型转换

变量

常量：final

运算符 优先级：（）

一元运算符

位运算符

赋值运算符

条件运算符

包机制

JavaDoc

Scanner：用户交互

Scanner进阶：

循环

if

switch

while

do-while

for

break

continue

goto关键字

方法

可变参数

递归

数组(Array):

数组初始化：

进阶方法：

二维数组：

Arrays类:

冒泡排序

冒泡排序的优化：

稀疏数组

面向对象

static

接口

异常

相关

运算符优先级：（）