Java学习笔记（近期更新）

Posted 2021-06-08 南风阿帅

1.案例“helloworld”

//定义了一个helloworld类
public class helloworld{
//    定义了一个main方法
    public static void main(String[] args) {
//        输出语句
        System.out.println("helloworld");
    }
}

2.关键字

修饰符：

abstract:抽象类修饰符
class:标准类修饰符
final:可以声明成员变量、方法、类以及本地变量,final变量是只读的.
private:修饰仅限于类的内部访问变量的修饰符.
protected:修饰可以用于子类的访问变量的修饰符.
public:修饰最大访问权限的访问变量的修饰符.
static:用于方便在没有创建对象的情况下来进行调用（方法/变量）的修饰符。
Java数据类型：

boolean:布尔型
byte:字节类型
char:字符型
double:双精度浮点型
float:单精度浮点型
int:整型
long:长整型
short:短整型
void:空类型,通常用于方法返回.
语句组成：

break:中断循环修饰符.
case:条件选择修饰符.
catch:异常处理修饰符.
continue:循环跳过修饰符.
default:条件选择默认条件修饰符.
do:循环修饰符
else:条件选择修饰符
extends:扩展子类修饰符
finally:异常处理修饰符.finally作为异常处理的一部分,不管是否异常最后都要处理这部分内容.
Java for:循环修饰符
if:条件选择修饰符
implements:加载接口类修饰符
import:引用类修饰符.
instanceof:支出判断对象是否是特定类修饰符.
interface:接口类定义修饰符.
new:新建类修饰符.
package:命名空间修饰符.
return:返回修饰符.
super:父类指针修饰符.
switch:条件选择修饰符.
sychronized:同步块修饰符.
this:本类指针修饰符.
throw:语句异常抛出修饰符.
throws:方法异常抛出修饰符.
try:异常处理修饰符.
while:循环处理修饰符.
特殊含义关键字：

assert:断言，用于调试，多被junit代替，IDE默认不开启。
const：预留关键字。
goto：预留关键字。
enum:枚举。
native:本地方法。
strictfp:精确浮点，可用于类、接口、方法。
transient:免除变量序列化。
volatile:被设计用来修饰被不同线程访问和修改的变量。
非java关键字：

true:布尔值真.
false:布尔值假.
null:空值修饰符.
serilizable:序列化修饰符.

3.常量

字符串常量、整数常量、小数常量、字符常量、布尔常量、空常量

//声明了一个helloworld类
public class helloworld{
//    定义了一个main方法
    public static void main(String[] args) {
//        输出语句
//        字符串常量
        System.out.println("helloworld");
//        整数常量
        System.out.println(1);
//        小数常量
        System.out.println(1.5);
//        字符常量
        System.out.println(\'%\');
//        布尔值
        System.out.println(1<2);
//        空常量（不能直接输出）
    }
}

4.数据类型

4.1基本数据类型

4.1.1数值型

整数

byte,short,int,long

浮点数

float,double

字符

char

4.1.2非数值型

布尔

boolean

5.变量

//声明了一个helloworld类
public class helloworld{
//    定义了一个main方法
    public static void main(String[] args) {
//        定义变量
        int a = 10;
        System.out.println(a);
        a = 20;
        System.out.println(a);
    }
}

变量名不能重复、变量需要复制后才能使用、定义long类型数据后面加L、定义float类型数据后面加F

成员变量和静态变量：

• 成员变量可以不赋初值，默认是数据类型的默认值；
• 成员变量只可以通过实例来访问；
• 静态成员变量可以通过 类名直接访问；

6.类型转换

6.1自动类型转换

//声明了一个helloworld类
public class helloworld{
//    定义了一个main方法
    public static void main(String[] args) {
        double a = 10;
        System.out.println(a);
    }
}

6.2强制类型转换

//声明了一个helloworld类
public class helloworld{
    //    定义了一个main方法
    public static void main(String[] args) {
        int k = (int)88.88;
        System.out.println(k);
    }
}
//k的值为88

7.运算符

7.1算术运算符

//声明了一个helloworld类
public class helloworld{
    //    定义了一个main方法
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/b);
        System.out.println(a%b);
    }
}
30;-10;200;0;10

7.2字符“+”操作

• 字符参加“+”操作的时候，是使用的ASCII值进行操作；
• 算术表达式中包含多个基本数据类型的时候，整个算数表达式结果的数据类型将会自动进行提升

//声明了一个helloworld类
public class helloworld{
    //    定义了一个main方法
    public static void main(String[] args) {
        int a = 10;
        char b = \'A\';//A的ASCII值是65
        char c = \'a\';//a的ASCII值是97
        System.out.println(a+b);
        System.out.println(a+c);
    }
}

7.3字符串“+”操作

//声明了一个helloworld类
public class helloworld{
    //	  实质上是拼接和算术运算操作,代码执行顺序为从前到后
    //    定义了一个main方法
    public static void main(String[] args) {
        System.out.println("a"+"b"+666);
        System.out.println(17+1+"的王帅");
    }
}

7.4赋值运算符

//声明了一个helloworld类
//注意：扩展的复制运算符底层隐含了强制转换数据类型的操作
public class helloworld{
    //    定义了一个main方法
    public static void main(String[] args) {
        int a=10;
        System.out.println("a是"+a);
        a += 20;
        System.out.println(a);

    }
}

7.5自增、自减运算符

//单独使用
//声明了一个helloworld类
public class helloworld{
    //    定义了一个main方法
    public static void main(String[] args) {
        int a=10;
        a++;
        System.out.println("a是"+a);
    }
}

//参与操作使用
//声明了一个helloworld类
public class helloworld{
    //    定义了一个main方法
    public static void main(String[] args) {
        int a=10;
        int b=a++;
        System.out.println("a是"+a);
        System.out.println(b);
    }
}

7.6关系运算符

==;!=;>;<;>=;<=

7.7逻辑运算

&&;||;!

7.8三元运算符

//声明了一个helloworld类
public class helloworld{
    //    定义了一个main方法
    public static void main(String[] args) {
        int a=10;
        int b=20;
        int c=a>b?a:b;
        System.out.println(a);
    }
}

7.8.1案例：两只老虎

//判断老虎的体重
public class helloworld{
    public static void main(String[] args) {
        int a=100;
        int b=200;
        boolean c = a==b ? true:false;
        System.out.println(c);
    }
}

1.8.2案例：三个和尚

//判断身高最高的和尚
public class helloworld{
    public static void main(String[] args) {
        int h1=100;
        int h2=200;
        int h3=300;
        int h = h1>h2?h1 : h2;
        int x = h>h3?h : h3;
        System.out.println(x);
    }
}

8.数据输入

//引入Scanner类
import java.util.Scanner;
public class helloworld{
    public static void main(String[] args) {
//        创建对象
        Scanner sc = new Scanner(System.in);
//        接收数据
        int x = sc.nextInt();
//        输出数据
        System.out.println(x);
    }
}

案例：三个和尚（升级）

//引入Scanner类
import java.util.Scanner;
public class helloworld{
    public static void main(String[] args) {
//        创建对象
        Scanner sc = new Scanner(System.in);
//        接收数据
        System.out.println("请输入第一个和尚的身高：");
        int a = sc.nextInt();
        System.out.println("请输入第二个和尚的身高：");
        int b = sc.nextInt();
        System.out.println("请输入第三个和尚的身高：");
        int c = sc.nextInt();
//        比较
        int h = a>b?a : b;
        int x = h>c?h : c;
//        输出数据
        System.out.println("三个和尚中最高身高是："+x+"cm");
    }
}

9.顺序结构

9.1流程控制语句——分支结构(if)

9.1.1if语句

public class helloworld{
    public static void main(String[] args) {
        int x = 10;
        if( x < 20 ){
            System.out.println("这是 if 语句");
        }
    }
}

9.1.2if...else...语句

public class helloworld{
    public static void main(String[] args) {
        int x = 30;
        if( x < 20 ){
            System.out.print("这是 if 语句");
        }else{
            System.out.print("这是 else 语句");
        }
    }
}

9.1.3嵌套的if语句

public class helloworld{
    public static void main(String[] args) {
        int x = 30;
        int y = 10;

        if( x == 30 ){
            if( y == 10 ){
                System.out.print("X = 30 and Y = 10");
            }
        }
    }
}

案例：考试成绩等级判断

//引入Scanner类
import java.util.Scanner;
public class helloworld{
    public static void main(String[] args) {
//        创建对象
        System.out.println("请输入考试成绩：");
        Scanner sc = new Scanner(System.in);
//        接收数据
        int score = sc.nextInt();
//        判断
        if (score>=90){
            System.out.println("优");
        }else if(score>=80&&score<90){
            System.out.println("良");
        }else if(score<80){
            System.out.println("差");
        }
    }
}

9.2流程控制语句——分支结构(switch)

public class helloworld{
    public static void main(String[] args) {
        int i = 5;
        switch(i){
            case 0:
                System.out.println("0");
            case 1:
                System.out.println("1");
            case 2:
                System.out.println("2");
            default:
                System.out.println("default");
        }
    }
}

9.2.1案例：春夏秋冬

import java.util.Scanner;
public class helloworld{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int month = sc.nextInt();
        switch (month){
                //case穿透原理
            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋季");
                break;
            case 12:
            case 1:
            case 2:
                System.out.println("冬季");
                break;
             default:
                 System.out.println("哈哈哈");
        }
    }
}

9.3流程控制语句——循环结构

9.3.1for结构

组成：初始化语句、条件判断语句、循环语句、条件控制语句

public class helloworld{
    public static void main(String[] args) {
        for (int i=1;i<=5;i++){
            System.out.println("Helloworld");
        }
    }
}

案例：求和

public class helloworld{
    public static void main(String[] args) {
        int sum = 0;
        for (int i=1;i<=5;i++){
            sum +=i;
        }
        System.out.println(sum);
    }
}

求偶数和

public class helloworld{
    public static void main(String[] args) {
        int sum = 0;
        for (int i=1;i<=5;i++){
            if (i % 2 ==0) {
                sum += i;
            }
        }
        System.out.println(sum);
    }
}

9.3.2while循环语句

public class helloworld{
    public static void main(String[] args) {
        int x = 1;
        while( x < 5 ) {
            System.out.print("value of x : " + x );
            x++;
            System.out.print("\\n");
        }
    }
}

案例：珠穆朗玛峰

public class helloworld{
    public static void main(String[] args) {
        double paper = 0.1;
        int i = 1;
        while( paper <= 884430 ) {
            paper *=2;
            i ++;
        }
        System.out.println(i);
    }
}

9.3.3do...while结构

public class helloworld{
    public static void main(String[] args) {
        int x = 10;
//        先执行语句，再判断条件
        do{
            System.out.print("value of x : " + x );
            x++;
            System.out.print("\\n");
        }while( x < 20 );
    }
}

9.3.4Random(产生随机数)

import java.util.Random;
public class helloworld{
    public static void main(String[] args) {
        Random r = new Random();
        int x = 10;
        for (int i = 1;i<=5;i++){
            int number = r.nextInt(10);
            System.out.println(number);
        }
    }
}

案例：猜数字大小游戏

import java.util.Random;
import java.util.Scanner;
public class helloworld{
    public static void main(String[] args) {
        Random r = new Random();
        int number = r.nextInt(100)+1;
        System.out.println("*****欢迎来到猜数字游戏*****");
        System.out.println("请输入你要猜的数字（1~100）：");

        while (true){
            Scanner sc = new Scanner(System.in);
            int guessNumber = sc.nextInt();

            if (guessNumber>number) {
                System.out.println("你猜的数字" + guessNumber + "大了,请重新输入：");
            } else if (guessNumber<number){
                System.out.println("你猜的数字"+guessNumber+"小了，请重新输入");
            }else{
                System.out.println("恭喜你，猜对了！");
                break;
            }
        }
    }
}

10.数组

10.1数组定义格式

int [] list;
int list [];

//二维数组
public class helloworld{
    public static void main(String[] args) {
        int [][] arr = new int[3][4];
        arr[0] = new int[]{1,2,3,4,5};
        System.out.println(arr);
    }
}

10.2数组动态初始化

int size = 10;
int [] list = new int[size];

10.3数组元素访问

public class helloworld{
    public static void main(String[] args) {
//        声明数组变量
        int size = 10;
        int [] list = new int[size];
//        访问list数组及其元素
        System.out.println(list[0]);
        System.out.println(list[1]);
        System.out.println(list[2]);
    }
}

10.4数组静态初始化

static：静态

修饰变量——变量是静态变量；

修饰方法——方法是静态方法，访问的时候可以直接通过 类名.方法名称；

注意——在静态方法中，只能调用静态的变量或方法，如果想要调用非静态变量和方法，可以通过创建这个类的实例，然后通过实例来调用非静态的变量和方法。

public class helloworld{
    public static void main(String[] args) {
//        声明数组变量
        int size = 10;
        int [] list = {1,2,3,4,5};
//        访问list数组及其元素
        System.out.println(list[0]);
        System.out.println(list[1]);
        System.out.println(list[2]);
    }
}

10.5常见操作

10.5.1遍历

//遍历指定元素
public class helloworld{
    public static void main(String[] args) {
//        声明数组变量
        int size = 10;
        int [] list = {1,2,3,4,5};
//        访问list数组及其元素
        for (int i=0;i<=4;i++){
            System.out.println(list[i]);
        };
    }
}

//遍历所有元素
public class helloworld{
    public static void main(String[] args) {
//        声明数组变量
        int [] list = {1,2,3,4,5,6};
//        访问list数组及其元素
        for (int i=0;i<=list.length;i++){
            System.out.println(list[i]);
        };
    }
}

10.6eclipse给main方法传参

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

11.方法

Java方法是语句的集合，它们在一起执行一个功能。

• 方法是解决一类问题的步骤的有序组合
• 方法包含于类或对象中
• 方法在程序中被创建，在其他地方被引用
• 注意：方法必须在创建后才能调用

11.1方法的定义和调用

public class helloworld{
    public static void main(String[] args){
//        调用方法
        isEvenNumber();
    }

//    定义一个方法
    public static void isEvenNumber(){
//        定义变量
        int number = 10;
//        判断是否是偶数
        if (number%2==0){
            System.out.println(true);
        }else {
            System.out.println(false);
        }
    };
}

11.1.1练习

public class helloworld{
    public static void main(String[] args){
//        调用方法
        getMax();
    }

//    定义一个方法
    public static void getMax(){
//        定义变量
        int a = 10;
        int b = 20;
//        判断是否是偶数
        if (a>b){
            System.out.println(a);
        }else {
            System.out.println(b);
        }
    };
}

11.2带参数方法定义和调用

public class helloworld{
    public static void main(String[] args){
//        调用方法
//        isEvenNumber(1);
        int number = 10;
        isEvenNumber(number);
    }


//    定义一个方法
    public static void isEvenNumber(int number){
        if (number%2==0){
            System.out.println(true);
        }else{
            System.out.println(false);
        }
    };
}

• 形参：方法定义中的参数；
• 实参：方法调用中的参数。

11.2.1练习

注意实参的顺序对应的形参的顺序

public class helloworld{
    public static void main(String[] args){
//        调用方法
        isEvenNumber(10,20);
    }
//    定义一个方法
    public static void isEvenNumber(int a,int b){
        if (a>b){
            System.out.println(true);
        }else{
            System.out.println(false);
        }
    };
}

11.3带返回值的方法定义和调用

• 方法定义的时候，return后面的返回值与方法定义的数据类型要匹配，否则就会报错；
• 方法的return值通常会使用变量进行接收，否则该返回值将无意义。

public class helloworld{
    public static void main(String[] args){
//        调用方法
        boolean x = isEvenNumber(10);
        System.out.println(x);
    }
//    定义一个方法
    public static boolean isEvenNumber(int a){
        if (a%2==0){
            return true;
        }else{
            return false;
        }
    };
}

11.4方法注意事项

• 方法不能循环嵌套定义；
• void表示无返回值，return可以省略，也可以单独书写，后面不添加数据；

11.5方法重载

在同一类中，相同名字但参数不同的方法

• 与返回值无关；
• 在调用的时候，Java虚拟机会通过参数的不同来区分同名的方法。

public class helloworld{
    public static void main(String[] args){
//        调用方法
        int result = sum(10,20);
        System.out.println(result);

        double result2 = sum(20.0,30.0);
        System.out.println(result2);

        int result3 = sum(10,20,30);
        System.out.println(result3);
    }
//    定义一个方法
    public static int sum(int a,int b){
        return a+b;
    };
    public static double sum(double a,double b){
        return a+b;
    };
    public static int sum(int a,int b,int c){
        return a + b + c;
    };
}

//使用方法重载思想，设计比较两个证书是否相同的方法，兼容全整数类型（byte、short、int、long）
public class helloworld{
    public static void main(String[] args){
//        调用方法
        System.out.println(compare(10,20));
        System.out.println(compare((byte) 10,(byte) 20));
        System.out.println(compare((short) 10,(short) 20));
        System.out.println(compare(10L,20L));
    }
//    定义一个方法
    public static boolean compare(int a,int b){
        return a==b;
    };
    public static boolean compare(long a,long b){
        return a==b;
    };
    public static boolean compare(byte a,byte b){
        return a==b;
    };
    public static boolean compare(short a,short b){
        return a==b;
    };
}

11.6方法的参数传递

11.6.1案例：数组遍历

//使用方法重载思想，设计比较两个证书是否相同的方法，兼容全整数类型（byte、short、int、long）
public class helloworld{
    public static void main(String[] args){
        int[] arr = {11,22,33,44,55};
        read(arr);
    }
//    public static void read(int[]arr){
//        for (int x = 0;x<arr.length;x++){
//            System.out.println(arr[x]);
//        }
//    };
public static void read(int[]arr){
    System.out.print("[");
    for (int x = 0;x<arr.length;x++){
        if (x == arr.length-1){
            System.out.print(arr[x]);
        }else {
            System.out.print(arr[x]+", ");
        }

    }
    System.out.println("]");
};
}

11.7成员方法和静态方法的区别

• 成员方法只能通过类的实例来调用；
• 静态方法可以直接通过类名来访问；

12.基础知识练习

12.1案例：减肥计划

//输入星期数，显示当天的减肥活动
import java.util.Scanner;
public class helloworld{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个星期数：");
        int week = sc.nextInt();
        
        if (week<1||week>7){
            System.out.println("你输入的星期数有误，请重新输入：");
        }else if (week==1){
            System.out.println("跑步");
        }else if (week==2){
            System.out.println("游泳");
        }else if (week==3){
            System.out.println("慢走");
        }else if (week==4){
            System.out.println("动感单车");
        }else if (week==5){
            System.out.println("拳击");
        }else if (week==6){
            System.out.println("爬山");
        }else {
            System.out.println("好好吃一顿");
        }
    }
}

//输入星期数，显示当天的减肥活动
import java.util.Scanner;
public class helloworld{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个星期数：");
        int week = sc.nextInt();

        switch (week){
            case 1:
                System.out.println("跑步");
                break;
            case 2:
                System.out.println("游泳");
                break;
            case 3:
                System.out.println("慢走");
                break;
            case 4:
                System.out.println("动感单车");
                break;
            case 5:
                System.out.println("拳击");
                break;
            case 6:
                System.out.println("爬山");
                break;
            case 7:
                System.out.println("好好吃一顿");
                break;
            default: 
                System.out.println("你输入的星期数有误，请重新输入：");
                break;
        }
    }
}

12.2案例：逢七过

public class helloworld{
    public static void main(String[] args){
        for (int x=0;x<=100;x++){
            if (x%10==7||x/10%10==7||x%7==0){
                System.out.print(x+",");
            }
        }
    }
}

12.3案例：数组元素求和

public class helloworld{
    public static void main(String[] args){
        int[] arr={11,22,33,44,55};
        int sum = 0;
        for (int x = 0;x<arr.length;x++){
            sum +=arr[x];
        }
        System.out.println("最终结果是："+sum);
    }
}

12.4案例：查找数组元素及索引

import java.util.Scanner;

public class helloworld{
    public static void main(String[] args){
        int[] arr={11,22,33,44,55};
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要查找的数据");
        int number = sc.nextInt();
        
////        定义一个索引值，初始值为-1
//        int index = -1;
////        遍历数组，获取数组中的每一个元素
//        for (int x=0;x<arr.length;x++){
//            if (arr[x]==number){
//                index = x;
//                System.out.println(index);
//            }
//        }
        
//        调用方法
        int index = search(arr,number);
        System.out.println(index);
    }

//    定义一个方法
    public static int search(int[]arr,int number){
        int index = -1;
//        遍历数组，获取数组中的每一个元素
        for (int x=0;x<arr.length;x++){
            if (arr[x]==number){
                index = x;
                break;
            }
        }
        return index;
    }
}

13.java面向对象

三大特征：封装、继承、多态、（抽象）。

13.1 Java类和对象

13.1.1类的定义

类是Java程序的基本组成单位，由属性和行为（方法、功能）组成。；

如果一个类中的方法没有使用static修饰，那么在调用的时候只能通过类的实例（对象）进行调用；

类的作用就是用来封装数据的；

类中还可以定义功能（方法）；

package student;
/**
*自定义数据类型
*Student理解成一个学生类的模板
**/
 public class student {
//    属性--成员变量
    String name;
    String cardID;
    char gender;

//    行为、功能、方法
//    有static修饰，静态方法
    public static void call(){
        System.out.println("打电话");
    }
//    无static修饰，静态方法
    public static void sendMessage(){
        System.out.println("发短信");
    }
}

13.1.2对象的定义

类模板的实例。

package student;
import java.util.Scanner;
/**
*自定义数据类型
*Student理解成一个学生类的模板(抽象出来的)
 * 张三这个学生就是一个具体的对象
**/
 public class student {
//    属性--成员变量（注意static修饰）--有默认值（数据类型的默认值）
    String name;
    String cardID;
    char gender;

//    行为、功能、方法
    public  void call(){
//        静态方法（static）里面只能调用静态的方法或变量
        System.out.println(name +"在打电话");
    }
    public  void sendMessage(){
        String a =10;//局部变量（没有附初始值是不能使用的）
        System.out.println("发短信");
    }
}

package student;

public class studentDemo {
    public static void main(String[] args) {
/**
 * student是类名；
 * p是对象名
 * 创建方法：类名 对象名=new 类名();//可以把这个对象叫做类的一个具体实例对象
 */
        student testData = new student();
        System.out.println(testData.name);//输出null
//        对象的属性
        testData.name = "张三";
        System.out.println(testData.name);//输出张三
        testData.gender = \'男\';
        testData.cardID = "000000";
//        对象的方法
        testData.call();//输出“张三在打电话”
    }
}

13.2.3匿名对象

//        匿名对象调用（只需要使用一次类的时候会用到匿名对象）
        new student().show();//输出 null--0.0

13.2.4包装类

13.2.5封装

1. 优点：

• 良好的封装能够减少耦合。
• 类内部的结构可以自由修改。
• 可以对成员变量进行更精确的控制。
• 隐藏信息，实现细节。

2. 原则：

• 把不需要对外提供的内容都隐藏起来。
• 把属性隐藏，提供公共方法对其访问。

private String name;//由于private的修饰，name属性只能在该类内部中访问，其他程序不能访问到该属性

3. 用户放置（不是读取）值

//    类中定义的方法
//    用户用来放置数据到“私有”属性变量的方法（同过该方法，用户能够够间接的访问到name属性）
    public void insertName(String pName){
        name = pName;
    }

//    对象
//    通过设定好的方法将数据设置到被封装好的属性中
        testData.insertName("王帅");

4. IDea的Generate

//    自动生成的get/set方法

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getCardID() {
        return cardID;
    }

    public void setCardID(String cardID) {
        this.cardID = cardID;
    }

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

13.2.5构造方法

可以通过构造方法来给类的成员变量（属性）进行赋值。

/*   无参数的构造方法，如果类中无构造方法，则默认就有一个无参的构造方法，如果类中有带参的构造方法，则默
 *    的构造方法就没有了
 */
    private student(){}

	student(){}

	public student(){}

//    带参数的欧早方法
public student(String name,String cardID){
        this.name = name;
        this.cardID = cardID;
    }

13.2继承

• 继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。
• 继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
• Java中不允许通过extends多继承，但是可以使用传递的方式进行多继承。
• 私有的成员变量不允许继承。
• java中所有类的鼻祖——object。

public class Dog extends Animal {
    private String name;
    public int leg = 4;

}

13.2.1继承中成员变量的关系

//如果所引用的子类中没有需要的属性或方法，则会再次到父类中去寻找

13.2.2super和this关键字

public AnimalTest() {
        super();//调用父类的无参构造方法（object）
    }

//static不能使用this和super

13.2.3继承中构造方法

• 在子类的构造器中必须要先调用父类构造器;
• 子类中会默认调用父类中的无参构造器。

ExtendsConstruct.java
    
    package test;

/**
 * 研究继承中构造器的调用关系（执行顺序关系）
 */
public class ExtendsConstruct {
    public static void main(String[] args) {
        ZhangWuji zhangwuji = new ZhangWuji();
        zhangwuji.show();

//        打印的是：
//        susu
//        jiji!
//        张无忌
//        苏苏
    }
}

YingSusu.java
    
    package test;

public class YingSusu {
    String name = "苏苏";
    public YingSusu(){
        super();//调用object的无参构造器
        System.out.println("susu");
    }
}

ZhangWuji.java
    
    package test;

public class ZhangWuji extends YingSusu {
    String name = "张无忌";
    public  ZhangWuji(){
        super();//调用的父类的无参构造    //子类会默认调用父类的无参构造器
        System.out.println("jiji!");
    }

    public void show(){
        System.out.println(name);
        System.out.println(super.name);
    }
}

13.2.4继承中的方法重写

• 如果调用的类中没有这种方法的话，就会去它的父类中去找。
• 可以用父类的方法，也可以通过重写去优化父类的方法；
• 父类中的静态方法在子类中不能被重写，但是在子类中可以写一个和父类方法名称一样的一个静态方法；
• 父类中的私有方法不能被重写；
• 子类重写父类中的方法，权限不能更低，即父类中的方法权限是public，子类中不能是private；
• 静态方法想要重写，只能写成静态的（静态的方法不能被重写，但是父类和子类可以有相同的静态方法，但是两者之间和继承毫无关系）

//    继承中方法的重写，和父类有一样的名称的方法，这种情况在同一类中叫做“方法重载”，在继承中叫做“方法重写”
    public void eat(){
        System.out.println("张无忌在吃饭");
    }

//    静态方法
    public static void fight(){
        System.out.println("苏苏在战斗");
    }

//    继承中方法的重写
    public void eat(){
        super.eat();
        System.out.println("张无忌在刷碗");
    }
//	  输出 苏苏在吃饭；张无忌在刷碗

//    重写的静态方法
    public static void figth(){

    }

13.2.5案例：求矩形面积及判断点是否在矩形之内

package Rectangle;

/**
 * 定义的一个长方形的类
 */
public class Rectt {
    private float width;
    private float heigth;

//    两个构造方法
//    属性初始化
    public Rectt(float width,float heigth){
        super();
        this.width = width;
        this.heigth = heigth;
    }
//    属性初始化值为10
    public Rectt(){
        super();
        this.width = 10;
        this.heigth = 10;
    }

//    定义两个get的方法

    public float getWidth() {
        return width;
    }

    public float getHeigth() {
        return heigth;
    }

    //    两个方法
//    求面积
    public float area(){
        float area = this.width * this.heigth;
        return area;
    }
//    求周长
    public float perimeter(){
        float perimeter = 2 * (this.width + this.heigth);
        return perimeter;
    }
}

package Rectangle;

public class PlainRect extends Rectt {
    private float startX;
    private float startY;
//    带参数的构造方法

    public PlainRect(float width, float heigth, float startX, float startY) {
        super(width, heigth);//调用父类的构造器，给宽和高赋值
        this.startX = startX;
        this.startY = startY;
    }
//    不带参数的构造方法
    public PlainRect(float width, float heigth) {
        super(0f, 0f);
        this.startX = 0;
        this.startY = 0;
    }

//    判断给点的点是否在矩形内
   public boolean isInside(double m,double n){
        if (
                m >= startX && m <= (startX + super.getWidth())
                        &&
                n >= (startY - super.getHeigth()) && n <= startY
        ){
            return true;
        }else {
            return false;
        }
   }
}

package Rectangle;

public class PlainRectTest {
    public static void main(String[] args) {
        PlainRect plainRect = new PlainRect(20,10,10,10);
//        求周长和面积
        float perimeter = plainRect.perimeter();
        System.out.println("周长是："+perimeter);
        float area = plainRect.area();
        System.out.println("面积是："+area);

//        判断点
        boolean inside = plainRect.isInside(25.5,13);
        System.out.println("是否在矩形之内："+inside);
    }
}