java学习笔记（小白学习）

最新推荐文章于 2023-10-19 16:46:19 发布

wenfei1997

最新推荐文章于 2023-10-19 16:46:19 发布

阅读量455

点赞数 1

分类专栏： java 文章标签： java 编程语言面向对象编程

本文链接：https://blog.csdn.net/wenfei1997/article/details/117128044

版权

java 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

chapter1java基础

dk jre jvm

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xpoFWGY9-1621587586531)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210428153654241.png)]

hello world

1.创建一个java文件

2.编写代码

3.编译javac java文件，会生成一个class文件

4.运行class文件，java class文件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a6cHQtpd-1621587586533)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210428170005977.png)]

可能会遇到的情况

1.每个单词的大小不能出现问题，java是大小写敏感的

2.尽量使用英文；

3.文件名和类名必须保证一致，并且首字母大写

4.符号使用了中文

java 程序运行过程

java是编译型和解释型的结合

步骤一编译过程：通过java编译器，java原文件变成class文件，class文件才被执行

代码：javac 文件名.java

步骤二解释过程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4bU9t3aF-1621587586535)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210428171827687.png)]

标识符（关键字）

Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符

标识符大小写敏感

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RSgRHPT1-1621587586538)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210429154309412.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-if9Vq123-1621587586540)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210429154545713.png)]

##数据类型

强类型语言：要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用

java、python属于强类型语言

弱类型语言

定义变量

String a=“hellp”

int b=10

Java的数据类型分为两大类
基本数据类型（primitive type）
引用数据类型（reference type）：基本数据类型外的，如string

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6nstJKq9-1621587586541)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210429155956603.png)]

整数类型一般int足够

浮点类型double足够

字符类型 char 如“中” 只能一个字 char name=“中”

String 字符串是一个类，属于引用类型，不是标识符 String name=“中国”

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0YZ6Cv4Z-1621587586542)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210429160749104.png)]

转义字符

\t制表符

\n换行符

布尔值扩展

boolean flag=ture;

if (flag==ture){}和 if (flag){} 是一样的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oDobFver-1621587586543)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210429162034451.png)]

类型转换

由于java是强类型语言，所以有些运算的时候，要进行类型转换

从低到高进行转换

小数的优先级大于整数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TgaAMgtX-1621587586544)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210429163011068.png)]

强制类型转换 （强制类型）变量名从高到低

int i=128;

byte b=（byte）i;（内存溢出）

自动类型转换 从低到高

int i=128;

double b=i;

1.不能对布尔值进行转换
2.不能把对象类型转换为不相干的类型
3.在把高容量转换到低容量的时候，强制转换
4.转换的时候可能存在内存溢出，或者精度问题！

变量

java是一种强类型语言，每个变量都必须声明其类型

java变量是程序中最基本的存储单元，要素包括变量名、变量类型和作用域

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YsRX0brG-1621587586545)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210430103349507.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Knpu2hGR-1621587586546)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210430104400244.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6bMmVnaI-1621587586547)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210430111151384.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SGvBfcmY-1621587586547)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210430112440319.png)]

重点：static、final、命名规范

public class day2 {
    /**
     1）类变量:static
     static double salary=2500

    属性：变量，从属于类，随着类出现和消失
    2）实例变量，从属于对象；如果不自行初始化，实
     例变量使用默认值，数值类型初始化一般为0或0.0，
    布尔值默认是false，除了基本类型其余都是null
     3)局部变量，必须声明和初始化值,只能在方法中使用
     4）常量 关键字 final 常量名=值 常量名一般用大写字符
   */
    static double salary=2500; //类变量
    String name; //实例变量
    int age; //实例变量
    //static final 是修饰符，不分前后顺序
    static final double PI=3.14;

    //main 方法
    public static void  main(String[] args){
        //3)局部变量 ：必须声明和初始化值,只能在方法中使用
        int i=10;
        System.out.println(i);

        //实例变量使用方法
        // 变量类型 变量名字=new day2()  变量类型是自己
        day2 day2=new day2();
        System.out.println(day2.age);
        System.out.println(day2.name);
    }

}

运算符

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kMnw2sNR-1621587586548)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210430113349113.png)]

public class yuhuofei {
    public static void main(String[] args) {
        // 与或非运算  && || ！
        boolean a= true;
        boolean b= false;
        System.out.println("b&&a:"+(b&&a)); //"+"为拼接，两个都为真，结果为真
        System.out.println("b||a:"+(b||a)); //其中一个为真，则为真
        System.out.println("!(b&&a):"+!(b&&a));//真变为假，假变为真

        //**短路运算**：若与或非运算执行到一部分时，即可判断，则后面的命令不再进行
        int c=3;
        boolean d=(c<2)&&(c++<4);  //c仍为3，c++没有执行
        
        System.out.println(d);
        System.out.println(c);


    }


}

+=；-=

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mtTMoKBu-1621587586549)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210502190800641.png)]

三元运算符

public class sanyuanyunsuanfu {
    public static void main(String[] args) {
        // x? y:z
        //如果x为真，则输出y否则输出z
        int score =40;
        String type= score<60 ? "不及格":"及格";
        //常与if搭配
        System.out.println(type);
    }

优先级用（）括起来！！

包机制

包机制本质是文件夹

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-R9im8x42-1621587586549)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210502192754333.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jtGmgm0j-1621587586550)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210502192944282.png)]

chapter2java流程控制

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xezWEofk-1621587586551)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210502194352342.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2Mu8KiJe-1621587586552)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210502200602788.png)]

package wenfeistu.jichupart.liuchengkz;

import java.util.Scanner;

public class scanner {
    public static void main(String[] args) {
        //创建一个扫描器对象，用于按收键盘数据
        Scanner scanner= new Scanner(System.in);

        System.out.println("使用next方式接收:");

        //判断用户有没有输入字符串
        if (scanner.hasNext()){
            //使用next方式接收
            String str=scanner.next();
            System.out.println("输出的内容为:"+str);
        }
        //凡是属于IO流的类如果不关闭会一直占用资源，要养成好习惯用完就关掉

        scanner.close();



    }

}

package wenfeistu.jichupart.liuchengkz;

import java.util.Scanner;

public class scanner_Nextline {
    public static void main(String[] args) {
        //创建一个扫描器对象，用于按收键盘数据
        Scanner scanner= new Scanner(System.in);

        System.out.println("使用nextLine方式接收:");

        //判断用户有没有输入字符串
        if (scanner.hasNextLine()){
            //使用nextline方式接收
            String str=scanner.nextLine();
            System.out.println("输出的内容为:"+str);
        }
        //凡是属于IO流的类如果不关闭会一直占用资源，要养成好习惯用完就关掉

        scanner.close();



    }

}

================================================

package wenfeistu.jichupart.liuchengkz;

import java.util.Scanner;

public class scanner3 {
    public static void main(String[] args) {
        Scanner scanner =new Scanner(System.in);

        //从键盘接收数据
        //定义变量
        int i=0;
        float f=0.0f;

        System.out.println("请输入整数：");
        if (scanner.hasNextInt()){
            i =scanner.nextInt();
            System.out.println("整数数据："+i);
        }else{
            System.out.println("输入的不是整数数据");
        }


        System.out.println("请输入小数：");
        if (scanner.hasNextFloat()){
            f =scanner.nextFloat();
            System.out.println("小数数据："+f);
        }else{
            System.out.println("输入的不是小数数据");
        }

        scanner.close();
    }
}

scanner进阶

package wenfeistu.jichupart.liuchengkz;

import java.util.Scanner;

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

    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ABvSIeeG-1621587586553)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210502205636264.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-q0B1hfcs-1621587586554)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210502205655242.png)]

if结构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-G7bh25Sh-1621587586555)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210503110647844.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cztRJqh7-1621587586556)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210503110741041.png)]

package chapter2liucheng.ifjiegou;

import java.util.Scanner;

public class ifdemo2 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);

        System.out.println("请输入成绩：");
        int score=scanner.nextInt();

        if (score>60 && score<70){
            System.out.println("及格");
        } else if(score>70 && score<=80){
            System.out.println("良好");
        } else if(score>80 && score<=100){
            System.out.println("优秀");
        } else if(score<60){
            System.out.println("不及格");
        }else{
            System.out.println("成绩不合法");
        }

        scanner.close();

    }
}

/*
if 语句至多有1个else语句，else语句在所有的else if语句之后
if语句可以有若干个else if语句，他们必须在else之前
一旦其中一个else if语句检测为true，其他的else if以及else都跳过
 */

switch

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VbAr0LtZ-1621587586556)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210503160537434.png)]

package chapter2liucheng.switchstu;

public class switch1 {
    public static void main(String[] args) {
        //case穿透,所以每写一个switch都要写一个break//switch匹配一个具体的值
        char grade ='A';
        switch(grade){
            case 'A':
                System.out.println("优秀");
                break;
            case 'B':
                System.out.println("良好");
                break;
            case 'C':
                System.out.println("及格");
                break;
            case 'D':
                System.out.println("加油");
                break;
            default:
                System.out.println("输入错误哦");

        }
    }
}

whie、do while

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-I4i2lcpF-1621587586557)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210503162048545.png)]

package chapter2liucheng.xunhuanjiegou;

public class while1 {
    public static void main(String[] args) {
        //计算1至100的和
        int i=1;         //初始化条件
        int sum=0;       //初始化条件
        while (i<=100){  //条件判断
            sum=sum+i;   //循环体
            i++;         //迭代
            System.out.println(sum);
        }

    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9MguaMEF-1621587586557)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210503162906868.png)]

package chapter2liucheng.xunhuanjiegou;

public class while2 {
    public static void main(String[] args) {
        int i=0;
        int sum=0;

        do {
            sum=sum+i;
            i++;
        }while (i<=100);
        System.out.println(sum);
    }
}

package chapter2liucheng.xunhuanjiegou;

public class while2 {
    public static void main(String[] args) {
        int i=0;
        int sum=0;
//while和do while 的区别
        while (i<0){
            i++;
        }
        System.out.println(i);//输出为0

        do {
            i++;
        }while (i<0);
        System.out.println(i);//输出为1
    }
}

for循环

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QGyVQHG6-1621587586558)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210503172944643.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pl5flTMK-1621587586559)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210503172832185.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-N46Cl956-1621587586559)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210503173737264.png)]

for循环执行步骤

1.最先初始化

2.条件判断

3.执行循环体

4.更新迭代

5.条件判断

6.执行循环体

7.更新迭代

2、3、4循环进行下去

package chapter2liucheng.forxunhuan;
//输出1000以内能被5整除的数，并且每行输出3个
public class for4 {
    public static void main(String[] args) {

        for (int i = 0; i <= 1000; i++) {
            if (i%5==0){
                System.out.print(i+"\t");
            }
            if (i%(5*3)==0){//每行3个
                System.out.print("\n");  
                //print()输出完不换行，println()输出后换行
            }
        }

    }
}

打印九九乘法表

package chapter2liucheng.forxunhuan;

public class for5 {
    public static void main(String[] args) {


       for(int i=1;i<10;i++){
           for (int j=1;j<=i;j++){
               int z=i*j;
               System.out.print(j+"*"+i+"="+z+"\t");

           }
           System.out.print("\n");
       }
    }
}
//1.我们先打印第一列，这个大家应该都会
//2，我们把固定的1序川一个循球但起来
//3，去牌重复项.i <=j
//4.调整整性式

break

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bWnEC06K-1621587586560)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210505105114006.png)]

package chapter2liucheng;

public class breakdemo {
    public static void main(String[] args) {
        int i=0;
        while(i<100){
            i++;
            if(i==30){
                break;
            }
        }
    }
}

package chapter2liucheng;

public class continuedemp {
    public static void main(String[] args) {
        int i=0;
        while(i<100){
            i++;
            if (i%10==0){
                System.out.println();
                continue;
            }
            System.out.print(i);

        }

    }
}
//break在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循坏中剩余的语句。（break语句也在switch 语句中使用）
//continua语句用在循坏离句体中，用于终止某次循环过程，即继过循环体中尚未执行的语句，接着进行下一次是否执行循坏的判定。

打印三角形

package chapter2liucheng.forxunhuan;

public class for6 {
    public static void main(String[] args) {
        for(int i=1;i<=5;i++){
            for(int j=5;j>=i;j--){
                System.out.print(" ");
            }
            for (int j=1;j<=i;j++){
                System.out.print("*");
            }
            for (int j=1;j<i;j++){
                System.out.print("*");
            }
            System.out.println();
        }

    }
}

chapter3java方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-diii2zJ7-1621587586560)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210505160919087.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oZAq8Q2u-1621587586561)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210505161038324.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RyZmpmJj-1621587586561)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210505162803272.png)]

package chapter3fangfa;

public class fangfa1 {
    public static void main(String[] args) {
   int b= max(10,10);

    }
    //比大小
    public static  int max(int num1,int num2){
        int result=0;


        if(num1>num2){
            result =num1;
        } else if(num1<num2){
            result=num2;
        }else {
            System.out.println("num1=num2");
            return 0;
        }

        return result;
    }

}

//return要写在方法的第一层

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-A29xOm52-1621587586562)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210505163719451.png)]

可变参数/不定项参数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5NWwW2Ek-1621587586562)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210505170511799.png)]

递归

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZrYARE9p-1621587586563)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210505171557073.png)]

package chapter3fangfa;
//递归思想，若递归次数太多，会影响计算机性能，不适合用递归
public class digui {
    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);
        }

    }

}

chapter4 java数组

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mTOSmRRZ-1621587586563)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210506104112074.png)]

数组声明创建

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rhorH1r0-1621587586564)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210506105553592.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gzRlE6ip-1621587586565)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210506111809677.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EycZQZf1-1621587586566)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210506112020327.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1DUObBdU-1621587586567)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210506155441294.png)]

Arrays类方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JKhj1i0f-1621587586567)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210506161228434.png)]

package chapter4Shuzu;

import java.util.Arrays;

public class array4 {
    public static void main(String[] args) {

        int[] a={1,2,3,34,909,40,5,30};
        System.out.println(a); //输出对象代码（查看不了数组元素）
        //打印（查看）数组元素
        //数组进行排序
        Arrays.sort(a);
        //将某个值付给数组中某些元素
        Arrays.fill(a,1,3,0);

        System.out.println(Arrays.toString(a));

    }
}

chapter5面向对象编程OOP

类=属性+方法

面向对象编程的本质：以类的方式组织代码，以对象封装数据。

以类组织代码，以对象封装数据。

类是一个抽象的模板，对象是一个具体的实例

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sHD6a5Ld-1621587586568)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210506171852062.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GdqEmGmH-1621587586569)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210506171859881.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KkbDqw4G-1621587586569)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210506174300819.png)]

package chapter5oop;
//oop1 类
public class oop1 {
    //main方法，方法都在类中
    public static void main(String[] args) {

    }

    /*
    修饰符 返回值类型 方法名(){
        //方法体
        return 返回值;
    }
     */
    //return 让结束方法，返回一个值，return后不再执行
    public String sayHello() {
        return "hello world";
    }
    //void 的return为空
    public void print(){
        return;
    }
    public int max(int a,int b){
        return a>b ? a:b;  //三元运算符
    }
}

方法的调用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mXykOVHN-1621587586570)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210507102726881.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w9fsFCqh-1621587586571)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210507102711662.png)]

构造器

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。

构造器有以下两个特点：

1.必须和类的名字相同

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-W1JcugKo-1621587586572)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210510120627152.png)]

package chapter5oop;

import sun.security.mscapi.CPublicKey;

public class person {
    //一个类即使什么都不写，它也会存在一个方法

    String name;//定义属性
    int age;//定义属性

    //实例化初始值
    //1.使用new关键字，本质是在调用构造器
    //2.构造器一般用来初始化值
    public person(){
        this.name="qinjiang"; //无参构造器的默认值是“qinjiang”
    }
        //有参构造：一旦定义了有参构造器，还需要使用无参构造器，就必须把无参构造器写出来
    public person(String name,int age){
             this.name=name;
             this.age=age;

    }
}


/*
package chapter5oop;
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        //new 关键词实例化了一个对象
        person person =new person("wenfei",23);//调用有参构造器
        System.out.println(person.name);
        person person1=new person();  //调用无参构造器
        System.out.println(person1.name);
    }

构造器：
1.和类名相同
2.没有返回值但也不写void
作用：
1.new本质在调用构造方法
2.初始化对象的值
注意点：
定义了有参构造器后，如果想使用无参构造，必须把有参构造写出来

生成构造器的方法：Alt+Insert

this.name=name;  前面的this.name是指类本身，后面的name是参数传进来的
 */

总结：类与对象

1.类与对象

类是一个抽象的模板，对象是一个具体的实例。

2.方法：定义和调用。

3.对象的引用：

引用类型：8大基本类型以外的都是引用类型

对象是通过引用来操作的：栈–>堆

4.对象的属性：字段Field、成员、变量

属性的默认初始化：

数字：0、0.0

char：u0000

boolean：false

引用：null

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

5.对象的创建和使用

–必须使用new关键字创建对象，必须调用构造器 person xiaoming=new person();

–对象的属性调用 xiaoming.name

–对象的方法的调用 xiaoming.sleep()

6、类：

静态的属性属性

动态的行为方法

封装

属性私有，get/set,避免程序对数据直接访问

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-62zOL4I0-1621587586573)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210508110431616.png)]

package chapter5oop;
//类  封装：private 属性私有，不可直接调用
public class fengzhuang {
    //名字属性
    private String name;
    //学号属性
    private int id;
    //性别属性
    private char gender;

    //**封装后，再提供一些public可以操作private属性的方法：get set

    //get获得这个数据
    public String getName(){
        return this.name;
    }
    //set给数据赋值
    public void setName(String name){
        this.name=name;
    }
//属性封装加多，方法较少

    //方法
    //学习（）
    //睡觉（）
/*
public class Application {
    public static void main(String[] args) {
        fengzhuang lianxi1=new fengzhuang();
        lianxi1.setName("wenfei");
        System.out.println(lianxi1.getName());
    }
    通过get读，set写
 */
//alt+insert 快捷添加get、set
    public char getGender() {
        return gender;
    }

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

    /*
    1.提高程序的安全性，保护数据
    2.隐藏代码的实现细节
    3.统一接口
    4.增加系统可维护性
     */

}

继承

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DyHW2ZiX-1621587586574)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210508112830558.png)]

package chapter5oop;
// 学生 is 人
//person 父类，xuesheng 子类、派生类
//继承是类与类之间的关系
// 子类继承了父类，则拥有了父类的**public**的**全部方法和属性**
// 私有private无法继承，一般属性才是私有的
//所有的类之间或间接继承object类，一个类只有一个父类，只有单继承，没有多继承
public class xuesheng extends person{
    public static void main(String[] args) {

    }


}

Super

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XlUMzoa1-1621587586574)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210510113037481.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uevA82yp-1621587586575)(C:\Users\phoeb\AppData\Roaming\Typora\typora-user-images\image-20210510113830133.png)]

super注意点

1.super调用符类的构造方法，必须在构造方法的第一个

2.super必须只能出现在子类的方法或构造方法中

3.super和this不能同时调用构造方法

this：

代表的对象不同：

this：本身调用着这个对象

super：代表父类对象的引用

前提：

this没有继承也可以使用

super只能在继承条件下使用

构造方法

this()：调用本类的构造

super()：调用父类的构造

方法的重写

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

1。子类和父类的方法名必须相同

2。参数列表必须相同

3.修饰符：方法重写范围可以扩大但不能缩小

public>protected>default>private

4.抛出的异常：范围可以被缩小但不能扩大

重写，子类的方法和父类的方法名必须要一致，方法体不同。

为什么需要重写：

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

重写：alt+insert：override；

package chapter5oop;

public class a extends b {
    //override 重写

    public  void test(){
        System.out.println("A=>test()");
    }
}
package chapter5oop;
//重写都是方法的重写，和属性无关
public class b {
    public static void test(){
        System.out.println("B=>test()");
    }
    }
}

import chapter5oop.a;
import chapter5oop.b;
//重写都是方法的重写，和属性无关
//重写的父类和子类的关键词都之只能是public
public  class Application {
    public static void main(String[] args) {

        //静态方法static的父类和子类：方法的调用只和左边定义的数据类型有关
        //静态方法只能在本类中使用，所以不能在其他类中重写
        //非静态的父类和子类：才可以重写
        a a=new a();
        a.test();
        //父类的引用指向了子类
        b b=new a();//a子类重写了父类的方法
        b.test();


    }
}
//