Java语法

准备阶段

• 先学会IDEA的基本调试

• 插件目前在用的是汉化版，在熟悉后尽量使用英文版（现已改成英文版）

• 调节字体大小,行间距,注释的颜色要会

注释

1. 单行注释 //
2. 多行注释 /**/
3. 文档注释 /** */

Java的基本语法

一、入门的科普

• 关于字节
• 强制转换

1. 强制转换的计算

package com.Ji.base;

public class Lesson4溢出问题 {
    public static void main(String[] args) {
        //当操作比较大的时候，注意溢出问题
        //JDK7 的新操作，数字之间可以用下划线区分
        int number = 10_0000_0000;
        int b = 30;
        int m = number*b; //-64771072
        long m2 =  number*b; //-64771072
        long m3 = number*((long)b); //30000000000  将一个数转化为另一个类型，好算

        System.out.println(m);
        System.out.println(m2);
        System.out.println(m3);
    }
}

2.强制转换的注意点

注意点：
        1.不能对布尔值进行转换
        2.不能把对象的类型转换为不相干的类型 （如上）
        3.在把高容量转换为低容量的时候，强制转换
        4.转换的时候可能存在内存溢出的问题

• 类型转换
  { 自动类型转换（高–>底）| 强制类型转换（低–>高） }

  低------------------------------------------------->高      
  byte -> short -> char -> int -> long -> float -> double
  运算中，不同的类型的数据先转化为同一信息，然后进行运算

• 常用的不同类型的定义方法

package com.Ji.base;

public class Lesson5常用定义方法 {
    public static void main(String[] args) {
        //int a,b,c
        //int a=1,b=2,c=3;
        String name="yuanhui";
        char a="A";
        double pi = 3.141;
    }
}

• 变量的类型以及初始化变量

变量的定义

type varName [=value] [{,varName[=value]}];
数据类型   变量名 = 值 ；可以使用逗号隔开来声明多个同类型的变量

    public static void main(String[] args) {
        //局部变量；必须声明和初始化值
        int i = 10;
        System.out.println(i);

        //变量类型 :new  Lesson6()
        Lesson6变量的所有类型 lesson6 = new  Lesson6变量的所有类型();
        System.out.println(new  Lesson6变量的所有类型().age);
        System.out.println(new  Lesson6变量的所有类型().name);

        System.out.println(salary);
    }

二、Java的数据类型

//整数类型  十进制   二进制0b  八进制0  十六进制0x
        int i = 10;
        int i2 = 010;//八进制0
        int i3 = 0x10;//十六进制0x   0~9  A~F 16

Java的数据类型分为两大类

-基本类型
  1. 数值类型：
       整数类型:
                1. byte（占1个字节）
                2. short（占2个字节）
                3. int（占4个字节）
                4. long（占8个字节）
       浮点类型:
                1. float（占4个字节）
                2. double（占8个字节）
  2. 字符类型:
                char（占2个字节）
2. boolean类型

eg float x = 100; 输出x的值，为100.0，如果时double 则为100.00

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

三、 Java的运算符

• 运算符

    算数运算符：+  -  *  /  %  ++  --
    赋值运算符：=
    关系运算符：>  <  >=  <=  ==  !=instanceof
    逻辑运算符：&&  ||  !
    位运算符：&  |  ^  ~  >>  <<  
    条件运算符：? :
    扩展赋值运算符： +=  -=  *=  /=

package com.Ji.operator;//包 的定义

public class Lesson1运算符 {
    public static void main(String[] args) {
        //ctrl+D 复制当前的代码行
        long a = 1234567891L;//long 类型要加L float类型要加f
        int b = 456;
        short c = 10;
        byte d = 7;

        System.out.println(a+b+c+d);//long 有long 转为long型，默认是int型
        System.out.println(b+c+d);//int
        System.out.println(c+d);//int

        int x = 10;
        int y = 20 ;
        int z =  41 ;
        System.out.println(x==y);
        System.out.println(x>=y);
        System.out.println(x<=y);
        System.out.println(z%y);
        //默认关系运算符的结果是布尔值，取余和C语言不一样，不需要写等号
    }

• 自增和自减

  package com.Ji.operator;

public class Lesson2自增和自减 {
    public static void main(String[] args) {
        int a = 5;
        int b = a++;//a = a + 1
        // a++ 后 a = 6 ，但是b的值为a++之前的值，输出为5
        int c = ++a;//c = a+1 先自增 再给c 赋值

        System.out.println(a);
        System.out.println(b);
        System.out.println(c);

        //幂运算我们要用类来进行 计算2*2*2=8
        double pow = Math.pow(2,3);
        System.out.println(pow);
    }
}

• 关系运算符

package com.Ji.operator;

public class Lesson3关系运算符 {
    public static void main(String[] args) {
        /*
        A = 0011 1100
        B = 0000 1101

        A&B = 0000 1100 (如果二者都为1，则都取1)
        A|B = 0011 1101 (如果二至其中有一个是1，则取1)
        A^B = 0011 0001 (异或 如果相同则为0 不同则为1)
        ~B = 1111 0010
         */

        //问： 如何计算2*8最快
        //按位来运算
        /*
        二进制
        0000 0001  1
        0000 0010  2
        0000 0011  3
        0000 0100  4
        0000 1000  8
        0001 0000  16
        */
        System.out.println(2<<3);
    }
}

• 逻辑运算

        //短路运算
        int c = 5;
        boolean d = (c<4)&&(c++<4);//在遇到第一个false时，说明c没有进行自增
        System.out.println(d);
        System.out.println(c);

• 简化运算

package com.Ji.operator;

public class lesson5简化运算 {
    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 Lesson6三目运算符 {
    public static void main(String[] args) {
        //三元运算符
        // x==true， 结果为y，否则结果为z
        int n = 80;
        String type = n <100 ? "1":"2";  
        System.out.println(type);
    }
}

四、 Java的关键字，标识符和作用域

• 关键字

  与C语言关键字类似，可以看图片

• 标识符
  1. 所有的标识符都应该以字母（A-Z 或 a-z）， 美元符（$），下划线开始(_)

  ​ 2. 首字符之后的字符可以是字母（A-Z 或 a-z），美元符（$），下划线（_）或是数字的任何字符组合

  ​ 3. 注意：不能使用关键字作文变量名或方法名
  ​

  ​ 4. 可以使用中文名来命名，但不推荐

• 作用域

  • 类变量
  • 实例变量
  • 局部变量

  public class Variable{
    static int allClicks = 0;//类变量
    String str = "hello world";//实例变量
    
    public void method(){
      int i = 0;//局部变量
    }
  }
  

五、 Java的包机制

包语句的语法格式为：

package pkg1[. pkg2[. pkg3...]];

一般是利用公司域名倒置作为包名；

导入包的语句

import package1[. package2...].(classname|*);

六、 Java生成的doc文档

Javadoc的作用是针对整个方法或者整个类做一个简要的概述的，使得别人不通过看具体方法代码就能知道某个方法或者某个类的作用和功能。写了Javadoc的在别人使用到类时，将鼠标悬停到类上或者方法上，javadoc会以提示信息显示出来，这样开发者在跳进源代码中就能知道类或者方法的作用。

Java的流程控制

一、 Java输入流Scanner

获取用户的输入：Scanner

    Scanner  s = new Scanner(System.in);

通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。

package com.Ji.Scanner;

import java.util.Scanner;

public class Demo1 {
    public static void main(String[] args) {
        // 创建一个扫描器对象，用于接收键盘数据
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入数据：");

        //判断用户有无输入字符串
        if(scanner.hasNext()){
            //使用next方式接受
            String str =scanner.next();
            System.out.println("输出的内容为："+str);

            scanner.close();//凡是属于IO（输入输出流）流类的，不用的话关掉，节省资源
        }
    }
}

hasNext()与hasNextLine()的区别

• next()
  1. 读取到有效字符后才可以结束输入
  2. 对输入有效字符前的空白，next()方法会自动将其去掉

     eg：Hello world 只输出Hello 123 456 只输出 123

  3. 只有输入有效的字符后才将其后面输入的空白作为分隔符或者结束符
  4. next()不能得到带有空格的字符串
• nextLine()
  1. 以Enter为结束符，nextLine()方法返回的是输入回车之前的所有字符
  2. 可以获得空白

     eg: 123 456 输出123 456

hasNext()与hasNextLine()的衍生

hasNextInt 判断缓冲是否有整数 有整数就返回 true 否则 false。

hasNextInt 缓冲区没有数据的时候就会等待，直到缓冲区有数据。

同：hasNextLine()， nextInt() ，nextByte()， nextShort() ， nextLong() ， nextFloat()， nextDouble()
9

二、 Switch case 语句

//case 具有穿透作用，如果不进行break的话会继续输出下一个case

package com.Ji.Scanner;

public class Demo5 {
    public static void main(String[] args) {
        String name = "远辉";

        //JDK7的新特性，表达式结果可以为字符串
        //字符的本质时数字

        //反编译   java---class （字节码文件）---反编译IDEA  Ctrl+shift+S+Alt可以打开项目结构
        switch (name){
            case "远辉"  :
                System.out.println("远辉");
                break;
            case "狂神" :
                System.out.println("狂神");
                break;
            default:
                System.out.println("无");
        }
    }
}

生成的.class文件(反编译)

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package com.Ji.Scanner;

public class Demo5 {
    public Demo5() {
    }

    public static void main(String[] args) {
        String name = "远辉";
        byte var3 = -1;
        switch(name.hashCode()) {
        case 941788:
            if (name.equals("狂神")) {
                var3 = 1;
            }
            break;
        case 1178413:
            if (name.equals("远辉")) {
                var3 = 0;
            }
        }

        switch(var3) {
        case 0:
            System.out.println("远辉");
            break;
        case 1:
            System.out.println("狂神");
            break;
        default:
            System.out.println("无");
        }

    }
}

三、 For循环

for循环的简写版

package com.Ji.Scanner;

public class For循环增强版 {
    public static void main(String[] args) {
        int [] numbers = {10,20,30,40,50,60};
        //遍历数组的元素
        for (int x:numbers){
            System.out.println(x);
        }
    }
}

Java的方法

一、方法的定义和调用

• 定义

  • 方法是解决一类问题的步骤的有序组合

  • 方法包含于类或对象中

  • 方法在程序中被创建，在其他地方被引用

    一个方法只完成一个功能 ，一个项目有且只有一个main方法，其余均通过调用来完成函数功能，类似于C语言的子函数

  • 方法的定义

  修饰符  返回值类型  方法名 （参数类型 参数名）{
      ...
       方法体
      ...
      return 返回值;
  }
  

  方法的实例:

package com.Ji.Method;

public class Demo2 {
    public static void main(String[] args) {
        int m = max(20,30);
        System.out.println(m);
    }
    //类似于C语言的子函数
    public static int  max(int a ,int b) {
        int result = 0;
        if(a==b){
            System.out.println("a==b");
            return 0;
        }
        if(a>b){
            result = a;
        }
        else {
            result = b;
        }
        return result;//记得加上返回值，因为这是一个可以返回的类型
    }

}

   public  String sayHello(){
       return "hello,world";
   }


    public  void print(){
        return;//返回一个空方法
    }

    public int max(int a,int b){
       return a>b? a : b; //三元运算符
    }

• 方法的调用
  1. 调用方法：对象名.方法名(实参列表)
  2. Java支持两种调用方法的方式，根据方法是否返回值来选择
  3. 当方法返回一个值的时候，方法调用通常被当做一个值。

     int larger =  max (30,40)
     

  4. 如果方法返回值时void，方法调用一定时一条语句

     System.out,println("Hello world");
     

静态方法与非静态方法的调用

package com.Ji.oop;

public class Demo2方法 {
    // 静态方法 static  调用相同的类可以立刻输出,注意类的名字
//    public static void main(String[] args) {
//        Demo3student.say();
//    }


    // 非静态方法 实例化类
    // 对象类型   对象名 = 对象值
    public static void main(String[] args) {
        Demo3student student = new Demo3student();
        student.say();
    }

}

package com.Ji.oop;
// 学生类
public class Demo3student {
    // 非静态方法
    public  void say() {
        System.out.println("学生说话啦!!!");
    }
}

• 参数类型
  1. 形式参数：在方法被调用时用于接收外界输入时的数据
  2. 实参：调用方法时实际传给方法的数据

package com.Ji.Method;

public class Demo1 {
    //main方法  a和b时实际参数
    public static void main(String[] args) {
            int sum = add(1,2);
            System.out.println(sum);
    }
    //此处的a和b时形式参数
    public static int add(int a,int b){
        return a+b;
    }
}

二、方法的重载

• 重载的定义：在一个类中，有相同函数名称，但形参不同的函数

  方法重载的规则：

  1. 方法名称必须相同
  2. 参数列表必须不同（个体不同，或类型不同，参数排列顺序不同等）
  3. 方法的返回类型可以相同也可以不相同
  4. 仅仅返回类型不同不足以成为方法的重载

     package com.Ji.Method;
  
   public class Demo3 {
   public static void main(String[] args) {
       int m = max(20,20,40);
       System.out.println(m);
   }
  
   //类似于C语言的子函数(通过改变max的类型，可以使得实参改变时适应于以下的函数)
   //1
   public static int  max(int a ,int b) {
       int result = 0;
       if(a==b){
           System.out.println("a==b");
           return 0;
       }
       if(a>b){
           result = a;
       }
       else {
           result = b;
       }
       return result;//记得加上返回值，因为这是一个可以返回的类型
   }
  
   //2.
   public static int  max(double a ,double b) {
       int result = 0;
       if(a==b){
           System.out.println("a==b");
           return 0;
       }
       if(a>b){
           result =(int) a;
       }
       else {
           result =(int) b;
       }
       return result;//记得加上返回值，因为这是一个可以返回的类型
   }
  
   //3.
   public static int  max(int a ,int b,int c) {
       int result = 0;
       if(a==b){
           System.out.println("a==b");
           result = c;
       }
       if(a>b){
           result = a;
       }
       else {
           result = b;
       }
       return result;//记得加上返回值，因为这是一个可以返回的类型
   }
   }
  
  

三、可变参数和递归

1. 可变参数
   定义：

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

package com.Ji.Method;

public class Demo4 {
    public static void main(String[] args) {
    Demo4 demo4 = new Demo4();
    demo4.text(1,3,2,5,7);
    }

    public void text (int...i) //可变参数必须放在最后一个，在它之前的必须都进行声明，且可变参数的类型都应该与main方法相同
    {
        System.out.println(i[0]);
        System.out.println(i[1]);
        System.out.println(i[2]);
        System.out.println(i[3]);
        System.out.println(i[4]);
        System.out.println(i[5]);
    }
}

2. 递归的写法

package com.Ji.Method;

public class Demo5 {
    public static void main(String[] args) {
        int i = 5;
        System.out.println(i + "的阶乘是" + f(5));
    }
    // 递归计算5！
     public static int f(int n){
        if(n == 1 || n == 0){
            return 1;
        }
        else{
            return n*f(n-1);
        }
     }
}

四、值传递和引用传递

1. 值传递

package com.Ji.oop;

public class Demo4值传递 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);//值为1 实参的值是不变的

        Demo4值传递.change(a);
    }

    public static void change(int a){
        a = 10;  //传递的是形参的地址,最后返回值为空,值仍未1
    }
}

2. 引用传递

package com.Ji.oop;

//引用传递,对象,本质还是值传递
public class Demo5引用传递 {
    public static void main(String[] args) {
        Person preson = new Person();
        System.out.println(preson.name);//null

        Demo5引用传递.change(preson);

        System.out.println(preson.name);//远辉
    }

    public static void change(Person person){
        //person是一个对象;指向  Person person = new Person();这是一个具体的人
        person.name = "远辉";
    }

//    定义了一个person类,有一个属性:name
static class Person{
        String name;//null
}
}

Java的数组

一、数组的声明和创建

1. 数组的定义
   首先必须声明数组变量，才能在程序中使用数组

   dataType[]  arrayRefvar;  //首选的方法
   dataType  arrayRefvar[];  //效果相同，但不是首选方法

Java语言使用new创建数组

 dataType[] arrayRefVar = new dataType[arraySize];

数组从零开始，获取数组的长度 arrays.length

2. 数组的初始化
   三种初始化

• 静态初始化

int [] a = {1,2,3};
Man[] mans = {new Man(1,1) , new Man(2,2);} 

• 动态初始化

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

package com.Ji.Array;

public class 数组的初始化 {
    public static void main(String[] args) {
        //静态初始化 创建 + 赋值
        int[] a = {1,2,3,4,5,6,7};
        System.out.println(a[0]);

        //动态初始化：包含默认初始化,int型的默认值是0 string类型的值为none
        int b [];
        b= new int[10];
        b[0] = 1;
        b[2] = 10;
        b[6] = 100;
        System.out.println(b[0]);
        System.out.println(b[1]);
        System.out.println(b[2]);
        System.out.println(b[3]);
        System.out.println(b[6]);
    }
}

1. 数组的声明

package com.Ji.Array;

public class 数组的声明 {
    // 变量的类型  变量的名字 = 变量的值
    //数组的类型
    public static void main(String[] args) {
      int[] n;//     定义

        /*
       int n1[];//      与C/C++语法相同，便于向Java过度
       * */

        // 简化的代码还可以写为   int[] n = new int[10];
        n =new int[10];

        n[0] = 1;
        n[1] = 2;
        n[2] = 3;
        n[3] = 4;
        n[4] = 5;
        n[5] = 6;
        n[6] = 7;
        n[7] = 8;
        n[8] = 9;
        n[9] = 10;
        //计算数组的长度 数组的长度用 array.length来表示
        int sum = 0;
        for (int i = 0;i < n.length;i++){
            sum = sum + n[i];
        }
        System.out.println("总和为" + sum);
    }
}

二、数组的增强

package com.Ji.Array;

public class 数组的增强 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        //JDK 1.5 没有下表 只限于输出遍历的数组
//        for (int array : arrays){
//            System.out.println(array); }

        // printArray方法
        printArray(arrays);
        }

    public static void printArray(int [] arrays){
        for (int i = 0; i < arrays.length;i++)
        {
            System.out.println(arrays[i]+"");
        }
    }
}

三、数组的类

API中提供了一个工具类Arrays供我们使用，具有以下常用功能：

• 给数组赋值：通过fill方法。
• 对数组排序：通过sort，按升序。
• 比较数组：通过equals方法比较数组中元素是否相等。
• 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。

package com.Ji.Array;

import com.sun.org.apache.xpath.internal.res.XPATHErrorResources_sv;

import java.lang.reflect.Array;
import java.util.Arrays;

public class 数组的类 {
    public static void main(String[] args) {
        int[] a = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21};
        System.out.println(a); //[I@1b6d3586
        //打印数组的元素  toString（arrays）
        System.out.println("================================");
        System.out.println(Arrays.toString(a));
        printArray(a);
        /*
        *   数组类的本质，是人写的  有int类 short类 char类
        *   public static String toString(int[] a) {
        if (a == null)
            return "null";
        int iMax = a.length - 1;
        if (iMax == -1)
            return "[]";

        StringBuilder b = new StringBuilder();
        b.append("[");
        for (int i = 0; ; i++) {
            b.append(a[i]);
            if (i == iMax)
                return b.append("]").toString();
            b.append(", ");
        }
    }
        *
        * */
    }
    public static void printArray(int[] a) {
        for (int i = 0; i < a.length; i++) {
            if (i == 0) {
                System.out.print("[");
                if (i == a.length - 1) {
                    System.out.println(a[i] + "]");
                } else {
                    System.out.println(a[i] + ",");
                }
            }
                                            }
    }
}

四、冒泡排序

package com.Ji.Array;

import java.util.Arrays;

public class 冒泡排序 {
    public static void main(String[] args) {
        int [] array = {1,3,5,51,63,20,7,9,12,17,23};

        int [] sort;//调用自己写的排序的方法
        sort = sort(array);

        System.out.println(Arrays.toString(sort));
    }

    public static  int[] sort(int [] array) {
        int tem ;//临时变量
        //外循环
        for (int i = 0; i < array.length - 1; i++) {
            boolean flag = false;//优化冒泡排序 如果数组已有部分排好序，则无需再进行排序

            for (int j = 0; j <= array.length -1-i; j++) {
                if (array[j + 1] < array[j]) {
                    tem = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = tem;
                    flag = true;
                }
            }
            if (flag) {
                break;
            }
        }
        return array;
    }
}

五、二维数组

  int a[][] = new int [2][5];

Java的面向对象

一、类与对象的创建

1. 类的定义：类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表一个具体的事物。
2. 对象是抽象概念的具体实例

• 能够体现出特点，展现出功能的是具体的实例
• eg：张三是人的一个具体实例，张三家的旺财是狗的一个具体实例。

二、什么是面向对象

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

三、创建与初始化对象

使用关键字new来创建对象

• 使用new关键字创建的时候，除了分配内存空间之外，还会给 创建好的对象 进行默认的初始化以及 对类中构造器的调用。
• 类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。有如下两个特点：
  

  1.必须和类的名字相同

  2.必须没有返回类型，也不能写void
  

四、构造器

package com.Ji.oop;

public class Demo6构造器 {
    //一个类即使什么都不写，它 也会存在一个方法
    //显示的定义一个构造器    构造器特点： 1. 必须和类的名字相同   2.没有返回值，且没有void
    String name;

    // 1. 使用new关键字，本质实在使用构造器，new出来默认产生一个构造器
    // 2.用来初始化值

    // 构造器
    public  Demo6构造器(){
//            这是无参构造
    }
    // 有参构造：一旦定义了有参构造，则无参就必须显示定义
    public  Demo6构造器(String name){
        this.name = name;//参数传递下来的name
        //左边：对象本身的name (String name;)
    }
//    快捷键 alt + insert
}

this.一般代表当前类的值，后面=一般是参数传进来的

package com.Ji.oop;

public class Demo6构造器1 {
//
public static void main(String[] args) {
//
    Demo6构造器 Demo6构造器 = new Demo6构造器("yuanhui");
    System.out.println(Demo6构造器.name);
}
}

五、小结

1. 内存分析

2.小结

1. 类与对象
   类是一个模板，抽象，对象是一个具体的实例
2. 方法
   定义，调用 ！
3. 对应的引用
   引用类型： 基本类型（8）
   对象是通过引用来操作的：栈–>堆
4. 属性
   • 默认初始化：数字 0 0.0
   • char :u0000
   • boolean :false
   • 引用：null

     修饰符 属性类型 属性名 = 属性值！

5. 对象的创建和使用
   • 必须使用new 关键字创造对象 ，构造器 Person p1 = new Person();
   • 对象的属性 p1.name
   • 对象的方法 p1.sleep
6. 类
   静态的属性 属性
   动态的行为 方法

Java的特性

一、封装

1. 封装的定义：

• 类的内部数据操作细节自己完成，不允许外部干涉
• 经暴露少量的方法给外部的类
• 通常，应禁止直接访问一个对象中数据的实际表示，而应通过接口来访问，这称为信息隐藏

2. 属性私有，get/set
3. Student类

    package com.Ji.oop.封装;

public class Student {
    //属性私有 private
    private String name; //名字
    private int id;       //学号
    private char sex;     //性别
    private int Age;

//    提供一些可以操作的这个属性的方法
//    提供一些public的get，set的方法

    //  get 获得这个数据
    public String getName() {
        return this.name;
    }

    //set 给这个数据设置值
    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return Age;
    }

    public void setAge(int age) {
        if (age > 120 || age < 0) {
            this.Age = 0;
        } else {
            this.Age = age;
        }
    }
}

Application类

package com.Ji.oop.封装;

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();

        s1.setName("远辉");

        System.out.println(s1.getName());

        s1.setAge(-1);//不合法的
        System.out.println(s1.getAge());
    }
}

二、继承

1. 继承的定义：继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
2. extands 子类是父类的扩展
3. Java中只有单继承，没有多继承！
4. 继承是类与类之间的一种关系，此外，类与类之间的关系还有以来、组合和聚合等。
5. 继承关系的两大类，一个为子类(派生类),()一个为父类(基类)

子类可以继承父类的所有方法

Application类

package com.Ji.oop.继承;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();
        System.out.println(student.money);
    }
}

Person类

package com.Ji.oop.继承;

public class Person {
    //public
    //protected
    //default
    //private
        int money = 10_0000_0000;

    public void say(){
        System.out.println("学生说了一句话");
//        ctrl + H 找到继承的类
//        在Java中，所有的项目都继承Java的object的类
     }
}

Student类

package com.Ji.oop.继承;
// 学生 is 人：派生类，子类
// 子类继承了父类，就会拥有父类的所有方法！
public class Student extends Person{

}

6. super

   super注意点

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

      与this的对比

   4. this 本身调用者这个对象
   5. super 代表父类对象的应用

      前提

   6. this 没有继承也可以使用
   7. super 只能在继承条件下使用

      构造方法

   8. this()本类的构造
   9. super()父类的构造

public void text(String name){
System.out.println(name);student.text(name:"")中的name
System.out.println(this.name);子类中的name
System.out.println(super.name);父类中的name
}

Application类

package com.Ji.oop.继承.super详解;

import com.Ji.oop.继承.Student;

public class Application {
    public static void main(String[] args)     {
        Student student = new Student();
    }
}

Student类

package com.Ji.oop.继承.super详解;

import com.Ji.oop.继承.Person;

public class Student extends Person {

    public Student() {
        //    隐藏代码，调用了父类的无参构造
        super(); //调用父类构造器必须在子类构造器的第一行
//        子类调用父类的有参，如果 super() 那么是调用不了父类的有参，它默认调用的是父类的无参；
//        故如果要调用父类的有参的话，就得在子类中加如参数的名字super（name："name"）
        System.out.println("Student无参执行了！");
    }
}

Person类

package com.Ji.oop.继承.super详解;

public class Person {
    public Person(){
        System.out.println("Person无参执行了！");
    }
}

7. 方法的重写

• 重写：需要有继承的关系，子类重写父类的方法
  1. 方法名必须相同
  2. 参数列表必须相同
  3. 修饰符：可以扩大但不能缩小：public->proteced->Default->private
  4. 抛出的异常，可以扩大但不能缩小
• 为啥需要重写？
  父类的功能，子类不一定需要、不一定满足
  快捷键 Alt + insert； override
  A

package com.Ji.oop.方法重写.静态方法;

//子类
public class A extends B{
//    @Override 重写
    @Override //注释，有功能的
    public void text(){
        System.out.println("A->text");
    }
}

B

package com.Ji.oop.方法重写.静态方法;

public class B {
    public void text(){
        System.out.println("B->text");
    }
}

Application

package com.Ji.oop.方法重写.静态方法;

public class Application {
//    方法的调用只和这个项目、定义的数据类型有关
public static void main(String[] args) {
    A a = new A();
    a.text();//  A

//    父类的引用指向子类
    B b = new A();  //子类重写了父类的方法
    b.text();// A

    /*
    public void text()
    非静态方法下的输出均为A
    public void text()
    静态方法下的输出一个是A，一个是B
    */


    /*
    * b 是 A new出来的对象，因此调用了A的方法
    * static是静态的方法，即是类的方法，而非静态是对象的方法
    * 有static时，b调用了B类的方法，b是有B类定义的
    * 无static时，b调用的对象的方法，b是由A new的
    * */
}
}

输出结果

A->text
A->text

三、多态

1. 定义：同一方法可以根据发送对象的不同而采取多种不同的方式
   （即一个对象的实际类型是确定的，但是可以指向对象的引用类型有很多）
2. 多态存在的条件
   • 有继承关系
   • 子类重写父类的方法
   • 父类引用指向子类对象

     Application

package com.Ji.oop.多态;

public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Student();
        //new Person();

        //可以指向的类型就不确定了：父类的引用指向子类

        //student 能调用的方法就是自己的或者继承父类的
        Student s1 = new Student();

        // person 父类型，可以指向子类，但是不能调用子类独有的部分
        Person s2 = new Student();
        Object s3 = new Student();
        //

        /*s2.run();//子类继承了父类的全部方法*/
        s1.eat();//子类方法的重写，执行子类的方法
        ((Student) s2).eat();//子类重写了父类的方法，强制转化后执行子类的方法
    }
}

Person

package com.Ji.oop.多态;

public class Person {

    public void run(){
        System.out.println("run");
    }
}
/*
* 多态的注意事项
* 1. 多态使方法的基础
* 2. 父类和子类，有联系，类型转换异常！ ClassCastException！
* 3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象
*
*   1. static 方法，属于类，不属于实例
*   2. final 常量
*   3. private 方法，是私有的，不能重写
* */

Student

package com.Ji.oop.多态;

public class Student extends Person{
    @Override
    public void run() {
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }
}

3. instanceof详解

Application

package com.Ji.oop.instancof;

import com.Ji.oop.多态.Student;

public class Application {
    public static void main(String[] args) {
        //Object > String
        //object > Person > Teacher
        //object > Person > Student
        Object object = new Student();

        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof  Object);//true
        System.out.println(object instanceof Teacher);//False
        System.out.println(object instanceof String);//False
        System.out.println("=================================================");

        Person person = new Student();
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof  Object);//true
        System.out.println(person instanceof Teacher);//False
//        System.out.println(person instanceof String);//False  编译报错，person和String是同级的

        Student student = new Student();
        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof  Object);//true
//        System.out.println(student instanceof Teacher);//False
//        System.out.println(student instanceof String);//False

Person

package com.Ji.oop.instancof;

public class Person {
}

Student

package com.Ji.oop.instancof;

import com.Ji.oop.多态.Person;

public class Student extends Person {

}

• instanceof能否编译通过

 System.out.println(X instanceof  Y);判断x所指向的类型是不是y所指向的类型

4. 多态小结
   1. 父类指向引用的对象
   2. 把子类转换为父类，向上转型
   3. 把父类转换为子类，向下转型，强制转换，可能会有方法的丢失

四、static关键字详解

1.变量

package com.Ji.oop.Static小结;

public class Student {
    private static int age;//静态的变量
    private double score;//非静态的变量

    public static void main(String[] args) {
        Student s1 = new Student();


        System.out.println(Student.age);//静态输出
        System.out.println(s1.score);
        System.out.println(s1.age);
    }
}

2. 方法
   非静态方法可以调用静态方法中的所有东西，静态方法调用不了非静态方法。

3. 代码块

package com.Ji.oop.Static小结;

public class Person {
    {
        System.out.println("匿名代码块");
    }
    static{
        System.out.println("静态代码块");
    }
    public Person(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person p1 = new Person();
        System.out.println("===================================");
        Person p2 = new Person();
    }
}

静态代码块值执行一次，并且最先输出！！！

输出结果：
静态代码块
匿名代码块
构造方法
===================================
匿名代码块
构造方法

4. 导入包

Java的抽象类

抽象类的特点

1. 不能new这个抽象类，只能靠子类来约束
2. 抽象类可以写普通的方法
3. 抽象的方法必须在抽象类中

package com.Ji.oop.抽象类;

public abstract class A {
    public abstract void doing();//abstract,只有方法名字，没有方法的实现
}

Java的接口

• 接口的本质是契约 比如我们规定好了某种东西：如果你是汽车，你就能开
• 接口的作用
  1. 约束
  2. 定义一些方法
  3. public abstract
  4. 常量 public static final
  5. 接口不能被实例化，接口中没有构造方法
  6. implements可以实现多个接口
  7. 必须重写接口中的方法

package com.Ji.oop.接口;

//interface 定义的关键字，接口都需要有实现类
//如果要在接口里面实现所有的定义，必须在类中重写方法
public interface UserService {
   //常量 public static final
   int age = 99;
   // 接口中定义的方法都是抽象的 public abstrac
   void add(String name);
   void delete(String name);
   void update(String name);
   void query(String name);
}

Java的内部类

内部类

1. 成员内部类
2. 静态内部类
3. 局部内部类
4. 匿名内部类

Java的报错类型总结

1. Error 和 Exception

• 检查性异常：eg：打开一个空文件，写函数调用函数陷入死循环等
• 运行时异常：运行的时候才报出异常
• 错误： 栈溢出
  Exception
  1. 运行时异常
  2. 数组下标越界
  3. 空指针异常
  4. 算数异常
  5. 丢失资源
  6. 找不到类

2. 捕获和抛出的异常
3. 自定义异常和小结

小结

• 刚刚开始入门学习后端开发，从最基础的Java语法开始学起，具体学习路线参照狂神说Java来学习的
• 后期学习还有些地方没有完善，还会继续努力的！