小白每天要努力-----Java入门简记

最新推荐文章于 2024-07-24 17:27:32 发布
最新推荐文章于 2024-07-24 17:27:32 发布
阅读量796 收藏 26
点赞数 15
分类专栏： JAVA基础 文章标签： java 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52605156/article/details/120123707
版权

文章目录

本博文是根据b站《狂神说Java》整理的代码示范，实际代码有很多，笔者选取了部分有代表性的代码，加以注释，难度对于刚入门JAVA的小白而言还可，如果有问题，欢迎在评论区留言，或者去b站寻找讲解视频。笔者也是刚学JAVA，推荐csdn一位博主----“编程界明世隐”，他的专栏里有蛮适合小白的《Java小白入门200例》，以及《从零学Java》。其他的大佬也有很多，大家选择自己喜欢的即可。

一、Java基本数据类型

package base;//栗子如下

public class demo02 {
    public static void main (String[] args) {
        //整数
        int num1=10;
        byte num2=20;
        short num3=30;
        long num4=40L;//long要加 L

        //浮点数
        float num5=50.1F;//float要加 F
        double num6=60.1;

        //字符类型
        char name='亲';
        String a = "hello";

        //布尔值
        boolen flag=true;

        System.out.println(a);
    }
}

我们再进行更多的比较：

package base;

public class demo03 {
    public  static void main(String[] args){
        int i=10;
        int i2=010;//八进制
        int i3=0x10;//十六进制

        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);
        //====================================
        //浮点数
        System.out.println("======================================");
        //BigDecimal 数学工具类
        //浮点数的特点： 有限， 离散， 舍入误差， 大约， 接近但不等于
        //不要用浮点数进行比较
        float f=0.1f;
        double d=1.0/10;
        System.out.println(f==d);

        float d1=231321213212f;
        float d2=d1+1;
        System.out.println(d1==d2);//已经越界了

        //================================
        System.out.println("======================================");
        char c1='a';
        char c2='种';
        System.out.println(c1);
        System.out.println((int)c1);
        System.out.println(c2);
        System.out.println((int)c2);
        //所有的字符本质还是数字
        //编码 Unicode 2字节  范围： 0-65536

        char c3='\u0061';\\转为a
        System.out.println(c3);

        //转义字符
        System.out.println("Hello\tWorld!");//Hello World
        //还有很多扩展
        String sa = new String ("hello");
        String sb = new String ("hello");
        System.out.println(sa==sb);

        System.out.println("======================================");

        String sc="hello";
        String sd="hello";
        System.out.println(sc==sd);


        System.out.println("======================================");
        //boolean
        boolean flag = true;
        if(flag==true){}
        if(flag){}


    }
}

输出结果为：
在这里插入图片描述
类型转换

package base;

public class demo04 {
    public static void main(String [] args){
        int i=128;
        byte b=(byte)i;//byte 取值范围 -128~127

        //强制转换 （类型）变量名  高到低
        //自动转换  低到高
        System.out.println(i);
        System.out.println(b);
        System.out.println((int)23.7);//23
        System.out.println((int)-45.89f);//-45

        char c='a';
        int d=c+1;
        System.out.println(d);
        System.out.println((char)d);
    }
}
/*
        1.不能对布尔值转换
        2.不能把对象类型转换为不相干类型
        3.高容量转换到低容量，强制转换
        4.转换的时候可能有内存溢出，或者精度问题
 */

运行结果：
在这里插入图片描述
溢出

package base;

import javax.swing.plaf.synth.SynthLookAndFeel;

public class demo05 {
    public static void main(String[] args){
        int money=10_0000_0000;
        int years =20;
        int tatal =money*years;//溢出
        long tatal2 =money*years;//转换为 long类型之前，已经溢出

        long total23 = money*((long)years);//先把一个数转换为long
        System.out.println(total23);
    }
}

变量

package base;

public class demo07 {

    //类变量

    //实例变量：丛属于对象；
    int age;
    //main方法
    public static void main(String[] args){
        //局部变量：必须声明和初始化值
        int i=10;
        System.out.println(i);

        demo07 Demo07 =new demo07();
        System.out.println(Demo07.age);
    }
    //其他方法
    public void add(){

    }

}

/*
运行结果：
10
0
*/

java命名规范

package base;

public class demo08 {
    public static final double PI=3.14;//常量之前的都是标识符，有无public均可，public 可以写成private
    //注意命名的规范
    /*类成员变量：首字母小写和驼峰原则
    例如：lastName
    局部变量：首字母小写和驼峰原则
    常量：大写字母和下划线
    类名：首字母大写，驼峰
    方法名：首字母小写和驼峰 run()
    */
    public static void main(String[] args){
        System.out.println(PI);
    }

}

运算符

package base;

import java.awt.desktop.SystemEventListener;

public class demo09 {
    public static void main(String[] args){
     //运算符
        int a=10;
        int b=20;
        long c=2545645645645L;
        int d=25;
        short e=10;
        byte f=8;

        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/(double)b);//
        System.out.println("======================================");
        System.out.println(c+d+e+f);//long //有long参与运算时，转为long
        System.out.println(d+e+f);//int
        System.out.println(e+f);//int 我们看一个short,一个 byte ，它运行完是int
        System.out.println("======================================");


    }

}

在这里插入图片描述

短路运算

package base;

public class demo10 {
    public static void main(String[] args){
        //math类
        double pow=Math.pow(2,3);
        System.out.println(pow);

        System.out.println("======================================");

        //短路运算
        int a=5;
        boolean b=(a<4)&&(a++<4);//判断错误，后面就不再运行了
        System.out.println(a);
        System.out.println(b);



    }
}

在这里插入图片描述
位运算

package base;

public class demo11 {
    public static void main(String[] args){
        /*
        A = 0011 1100
        B = 0000 1101
        -----------------
        //我们 A 和 B 一位一位比对，得出结果
        A&B = 0000 1100   //当全部为1的时候，是1
        A|B = 0011 1101   //有一个1，就是1
        A^B = 0011 0001   //不同为1，相同为0
        ~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);

    }
}

" "的位置

package base;

public class demo12 {
    public static void main(String[] args){
        int a=10;
        int b=20;
        System.out.println(" "+a+b);//先转换为字符串
        System.out.println(a+b+" ");//先转换为数

        //x?y:z
        //如果x==true.则结果为y,否则结果为z

    }
}

/*结果是：
  1020
 30
 */

二、Scanner基本使用

接收数据

package base2;

import java.util.Scanner;

public class Demo01 {
    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);
        }

        scanner.close();//使用IO流，用完关掉
    }
}
//注意：next不能得到有空格的字符串

运行结果：
在这里插入图片描述
那我们想在字符串里面加空格，我们就要用到下面的方式：

package base2;

import java.util.Scanner;

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

        System.out.println("使用nextLine方式接受：");

        if(scanner.hasNextLine()){
            String str = scanner.nextLine();
            System.out.println("输出内容："+str);
        }
        scanner.close();
    }
}
//以回车为结束符

在这里插入图片描述
做一个栗子，我们输一个数，判断是否符合当前类型，并且输出：

package base2;

import java.util.Scanner;

public class Demo04 {
    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("输入的不是小数。");
        }

    }
}

运行结果：
在这里插入图片描述

有的时候我们或许会遇到让我们一个个输入，但是输多少个却不能提前预判，那我们也可以使用hasNextDouble来帮助我们，比如下面这个栗子，我们用一个“ / ”结束输入：

package base2;

import java.util.Scanner;

public class Demo05 {
    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=m+1;
            sum=sum+x;
            System.out.println("你输入了第"+m+"个数据，当前结果为sum="+sum);
        }

        System.out.println(m+"个数的和是"+sum);
        System.out.println(m+"个数的平均数是"+(sum/m));
        scanner.close();
    }
}

运行结果：
在这里插入图片描述

equals：
快速判断字符串是否相等，用法如下：

package base2;

import java.util.Scanner;

public class Demo06 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入内容：");
        String s = scanner.nextLine();

        // equals:判断字符串是否相等
        if(s.equals("Hello")){
            System.out.println(s);
        }

        System.out.println("End");
        scanner.close();
    }
}

找素数

package base2;

public class Demo09 {
    public static void main(String[] args) {
        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;//我们如果发现这个数在除了1和它本身外，其他数也满足条件的时候，我们就使用continue返回到outer这个方法继续执行
                }
            }
            System.out.println(i+" ");
        }
    }
}

打印三角形

package base2;

public class Demo10 {
    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( );
        }
    }
}

三、数组基本使用

求数组里的最大元素，but 这个数组的数据类型好像难确定
我们的数组一般定义为int 或者是double ,那么如果一组数据里面，既有整型，也有浮点型，那是不是有点恶心了呢？JAVA里面有一种方法可以帮到我们：

package base3;

public class Demo03 {
    public static void main(String[] args) {
            printMax(34,3,3,2,56.5);//我们传入了整数和小数
            printMax(new double[]{1,2,3});
    }
    public static void printMax(double... numbers){
        //我们看 (double... numbers), double加 三个点 就是指不确定传进来的是什么类型的数字
        if(numbers.length == 0){
            System.out.println("java内卷之王！");
            return;
        }
        double result = numbers[0];

        //比较
        for(int i=1;i<numbers.length;i++){
            if(numbers[i]>result){
                result=numbers[i];
            }
        }
        System.out.println("最大的是："+result);
    }
}

运行结果：
在这里插入图片描述

递归

package base3;
//递归
public class Demo04 {
    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);
        }
    }
}

把数组里的元素逆过来

package base3;

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

        int[] arrays = {1,2,3,4,5};
        int[] reverse = reverse(arrays);//定义reserver数组接受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]+" ");
        }
    }


}

二维数组初涉

package base3;

public class Demo08 {
    public static void main(String[] args) {
        int[][] array = {{1,2},{2,3},{3,4},{4,5}};

        printArray(array[0]);//我可以都打印
        System.out.println();
        printArray(array[1]);//我也可以打印某行
        System.out.println();
        printArray(array[2]);//就是这么神奇
        System.out.println();
        printArray(array[3]);//。。。。。。
    }

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

把数组打印出来，可不只是简简单单print

package base3;

import java.util.Arrays;

public class Demo09 {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5,465,2,11,546};
        //System.out.println(a);//错误
       System.out.println(Arrays.toString(a));//正确
    }

}

冒泡排序

package base3;

import java.util.Arrays;

public class Demo10 {
    public static void main(String[] args) {
        int[] book={5,2,6,1,4,3,8};
        sort(book);
        System.out.println(Arrays.toString(book));
    }

    public static void sort(int[] book) {
        int temp;
        for(int i = 0 ; i < book.length-1 ; i++){
            for(int j = 0 ; j < book.length-1-i ; j++){
                if(book[j]>book[j+1]){
                    temp=book[j];
                    book[j]=book[j+1];
                    book[j+1]=temp;
                }
            }
        }
    }
}

稀疏数组
简单来说，比如我们玩五子棋，刚开始的时候，比如我们只下了两颗棋子，这时，要是用程序模拟我们的棋盘，我们可以把棋盘上每一个点都表示出来，但是，是不是太占空间了呢？这时，使用稀疏数组就可以解决问题。
稀疏数组，第一行，前两个数是指原来数组有几行几列，最后那个数是指现在棋盘上有几个棋子，也就是有效值的个数，下面的几行就是用行列去描述具体这些点的对应坐标：

package base3;
//稀疏数组
//记录有效坐标的信息，还原回原来的样子
public class Demo11 {
    public static void main(String[] args) {
        //创建一个二维数组，0是无棋子， 1是黑棋， 2是白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //输出原始数组
        for(int[] ints:array1){
            for(int anInt : ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        System.out.println("====================");
        //转换为稀疏数组
        //获取有效值的个数
        int sum = 0;
        for(int i=0;i<11;i++){
            for(int j = 0; j<11; j++){
                if(array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值个数："+sum);

        //创建一个稀疏数组
        int[][] array2 = new int[sum+1][3];//有效值加一是行数

        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;//表头打印出来了

        //遍历二维数组，将非零的值存入到稀疏数组里面
        int count = 0;
        //外层for循环表示数组的行，内层for循环表示稀疏数组的列，if来进行判断
        for (int i = 0;i<array1.length;i++){
            for(int j = 0;j<array1[i].length;j++){
                if(array1[i][j]!=0){
                    count++;
                    array2[count][0]=i;
                    array2[count][1]=j;
                    array2[count][2]=array1[i][j];
                }
            }
        }
        System.out.println("稀疏数组：");
        for(int i =0;i<array2.length;i++){
            System.out.println(array2[i][0]+"\t"
                    +array2[i][1]+"\t"
                    +array2[i][2]+"\t");
        }
        System.out.println("======================");

        System.out.println("还原稀疏数组");

        //读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //给其他元素还原值
        for(int i = 1;i<array2.length;i++){
            //i在1开始，因为i=0的时候，打印出来的是表头，否则会越界。
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        //打印
        System.out.println("还原的数组：");
        for(int[] ints : array3){
            for(int anInt : ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

    }
}

运行结果：
在这里插入图片描述

四、面向对象编程

是类啊
我们简单来看一个类，比如我们定义一个菜鸟类，首先我们先想，我们这个菜鸟会干什么，它应当有它自己的属性，还有菜鸟自己的一些特殊本领：

package base4;

 public class cainiao {
    //属性
    String name; //null
    int age; //0
    //方法
    public  void cjb() {
        System.out.println(this.name+"cjb");
    }
}

然后我们再说，主类里面怎么使用：

package base4;

public class Application {
    public static void main(String[] args) {
        //类：抽象化，实例化
        //类实例化后会返回一个自己的对象
        //student对象是student类的一个具体的实例
        cainiao xiaocainiao = new cainiao();
        cainiao dacainiao = new cainiao();

        xiaocainiao.name = "小菜鸟";
        xiaocainiao.age = 1;

        System.out.println(xiaocainiao.name);
        System.out.println(xiaocainiao.age);

        dacainiao.name = "大菜鸟";
        dacainiao.age = 2;

        System.out.println(dacainiao.name);
        System.out.println(dacainiao.age);

        xiaocainiao.cjb();//方法调用
        dacainiao.cjb();

    }
}

运行结果：
在这里插入图片描述

我们也可以把类写到一起，不过建议分开写，一个类完成一个任务就可以了。

package base4;
//引用传递 ： 对象，本质还是值传递
public class Demo03 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);//null

        Demo03.change(person);

        System.out.println(person.name);//大帅逼
    }

    public static void change(Person  person) {
        //person是一个对象，指向的--->Person person = new Person();是一个具体的人，可以改变属性
        person.name = "大帅逼";
    }
}
//定义了一个Person类，有一个属性是name
class Person{
    String name;
}

this
我们在Application的测试类里面定义一个学生类，然后在学生类里再定义方法：

package base5;

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("张三");

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

        s1.setAge(999);//非法数据
        System.out.println(s1.getAge());
    }
}

然后我们看一下学生类：

package base5;

public class Student {
    //属性私有
    private String name;
    private int id;
    private char sex;
    private int age;
    //提供获取属性的方法
    //get
    public String getName(){
        return name;
    }

    //set
    public void setName(String name){
        this.name=name;
    }
    //alt +insert 选中 Getter 和 Setter

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age>120||age<0){
            this.age = 3;//三岁小孩智商
        }else{
            this.age = age;
        }

    }
}

继承
我们先定义一个主类，在里面定义一个学生类：

package base7;
//测试类
import base7.Student.*;
public class Application {
    public static void main(String[] args) {

        Student student = new Student();
        student.test1();
    }
}

这个时候，我们先不着急定义学生类，我们先定义一个人的类，也就是父类。

package base7;
//父类
public class Person {
    public Person() {
        System.out.println("无参");
    }

    protected String name ="大笨蛋";

    public void print(){
        System.out.println("小菜鸡");
    }
}

然后我们让学生类去继承我们的父类：

package base7;
//子类
public class Student extends Person {
    public Student() {
        //这里有一段隐藏代码 ，它调用了父类的无参构造
        System.out.println("无参2");
    }

    private String name="大菜鸟";

    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);

    }

    public void print(){
        System.out.println("小菜鸟");
    }

    public void test1(){
        print();
        this.print();
        super.print();
    }
}

运行结果：
在这里插入图片描述

重写

package base8;

public class Application {

    public static void main(String[] args) {
//静态方法：方法的调用只和左边，定义的数据类型有关
//非静态 ： 重写
        A a = new A();
        a.test();//A
//父类的引用指向了子类
        B b = new A();//子类重写了父类方法（非静态）
        b.test();//B
    }
}

/*
重写：需要有继承关系，子类重写父类的方法，不能是属性
1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大 ：public>protected>default>private
4.抛出的异常：
范围可以被缩小，但是不能被扩大：ClassNotException

重写：子类的方法和父类一致，方法体不同

重写的意义：
1.父类的功能，子类不一定需要，或者不一定满足
Alt+Insert :override
*/

我们看B类是怎么定义的：

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

    }（错误）*/

    public void test() {
        System.out.println("B=>test()");


    }
}

A类：

package base8;

public class A extends B {
  /*  public static void test(){
        System.out.println("A=>test()");

    } （错误）*/
   public void test(){
       System.out.println("A=>test()");
   }

}

运行结果：
在这里插入图片描述

多态

package base9;

public class Application {
    public static void main(String[] args) {
        /*
        一个对象的实际类型是确定的
        new Student;
        new Person;*/
        //可以指向的引用类型就不确定了

        //子类能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        //父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 =new Student();
        Object s3 = new Student();

        s2.run();//子类重写了父类的方法，执行了子类的方法
        s1.run();

//对象能执行那些方法，主要看对象左边的类型
        s1.eat();
      // s2.eat();//person里面没有
//子类没有重写父类，调用父类的。如果子类重写了父类，调用子类的

    }
}

我们看一下Person类里的代码：

package base9;

public class Person {
    public void run(){

    }
}

/*
 多态
 1.多态是方法的多态，属性没有多态性
 2.父类和子类，有联系，类型转换异常
 3.存在条件：继承关系，方法需要重写，父类引用指向子类对象
（1.）static 方法，属于类，不属于实例
（2.）final 常量（常量池）
（3.）private 方法
 */

Student类中的代码：

package base9;

public class Student extends Person{

        public void run(){
            System.out.println("跑步");
        }

        public void eat(){
            System.out.println("吃饭");
        }
}

我们发现Person类里是没有写方法具体实现步骤，但是我们看运行结果，会发现父类执行了子类的方法：
在这里插入图片描述

是 instanceof 呢
instanceof 是 Java 的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。

package base10;

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);//flase
        System.out.println(person instanceof String);//编译错误
        System.out.println("===========================");

        Student student = 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 obj = new Student();
        //高                 //低
        //强制转换
      // ((Student)obj).go();
*/

    /*    Student student = new Student();
        student.go();
    }
}*/
/*
1.父类引用指向子类的对象
2.把子类转换为父类，向上转型
3.父类转子类，向下转型，强制转换
4.方便调用，减少重复代码
 */

Person.java

package base10;

public class Person {
    public void run(){
        System.out.println("run");
    }

}

Student.java

package base10;

public class Student extends Person{
    public void go(){
        System.out.println("go");
    }
}

Teacher.java

package base10;

public class Teacher extends Person{
}

杂项

package base11;

    public class Person {
        {
            System.out.println("匿名代码块");  //2
        }
        static {
            System.out.println("静态代码块");  //1  只输出一次
        }
        public Person(){
            System.out.println("构造方法");  //3
        }

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

运行结果：
在这里插入图片描述

是接口呢

package base11.demo;
//利用接口实现多继承
//实现接口里的类，需要重写接口里的方法
public class UserServiceimp implements UserService ,TimeServer{
    @Override
    public void run(String name) {

    }

    @Override
    public void add(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void query() {

    }
}

/*
约束
定义方法，让不同人实现
public abstract
public static final
接口不能被实例化，接口里没有构造方法
implements可以实现多个接口
必须重写接口中的方法
*/

看一下接口的定义：

package base11.demo;

public interface UserService {
    //接口中所有定义都是抽象的public
    //public abstract void run();
    void run(String name);
    void add(String name);
    void update(String name);
    void query(String name);
}


package base11.demo;

public interface TimeServer {
    void query();
}

是内部类呢

package base12;
public class Application {
    public static void main(String[] args) {
        //new
        Outer outer = new Outer();
        //通过外部类来实例化内部类
      //  outer.new Inner();

        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();
    }
}

看一下Outer.java

package base12;

public class Outer {
   private int id=10;
    public void out(){
        System.out.println("这是外部类");
    }
    class Inner{
        public void in(){
            System.out.println("这是内部类方法");
        }

        //获得外部类的私有属性
        public void getID(){
            System.out.println(id);
        }
    }

}

在这里插入图片描述

文中若有不足疏忽之处，请各位大佬在评论区留言，笔者JAVA也只是刚学，希望能一起努力进步，感谢各位的支持。

JAVA-从入门到 ？

敲代码的xiaolang
关注
  • 15
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 17
    评论
专栏目录
factorytalk-view-入门培训教程.pdf
12-25
------深圳库马克 杨小贤 ME 工程设计简记： 1、 新建工程 "文件"菜单中选择"新建应用程序" ，弹出如下对话框： 输入应用程序名称，语言选择英语（en-US） ，然后单击创建完成新建程序，如果想要导入 其他的工程，...
原理图的绘制简记-原理图设计经验
08-21
在进行PCB布线的时候要多加注意哦，尤其是cpu芯片的每一个电源端都要接一大一小的电容，你会发现它的电源分布一般都是很均匀的哦。 原理图设计需要考虑许多因素，需要设计师具备深入的电路知识和经验。
crc16校验java实现
01-17
从数据头到校验码前的CRC16-CCITT的校验值，遵循大端排序方式的规定。CRC16-CCITT码生成多项式为x16+x12+x5+1，简记式1021。
前端大厂最新面试题-selector.docx
06-06
CSS 选择器详解 ...选择器所选择的元素，叫做“选择器的对象”。...因此，优先级可以简记作 (0, 1, 1, 3)。比较规则为： * 从左往右依次进行比较，较大者优先级更高 * 如果相等，则继续往右移动一位进行比较
2013-6-3珠海移动暑假实习面试简记
04-19
这篇博客文章标题为“2013-6-3珠海移动暑假实习面试简记”，从标题我们可以推测，本文作者分享了自己在2013年6月3日参加珠海移动公司暑假实习面试的经历和感悟。这是一篇关于求职经验、面试技巧以及可能遇到的问题的...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1157
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
redis+spring面试题
github_36510643的博客
07-21 419
redis+spring面试题
Java-Lambda
lizhiwei21的博客
07-21 458
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Java内存模型
weixin_44267758的博客
07-19 797
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 785
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
最新发布
weixin_43561432的博客
07-24 156
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
java算法day19
TOMOT77的博客
07-20 330
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
淘客返利系统中的服务发现与注册机制详解
技术研究中心
07-22 1898
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 978
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
【Java并发编程之美 | 第三篇】Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
踢桃的成长之路
07-21 833
Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
4.Jmeter接口性能测试
weixin_43444329的博客
07-23 683
系统用户数：软件系统注册的用户总数（要注意初始化环境）在线用户数：某段视角内访问用户数，这些用户只是咋先，不一定同时做某一件事情。（初始化环境（warm up热机：让系统接近运行的系统，让系统运行更快 磁盘->内存））并发用户数：某一个时间同时向系统提交请求的用户数，场景不一定是同一个。：测试web系统的性能，支持多少并发？在确定并发用户数之前，必须先对用户的业务进行分解，分析出其中的典型业务场景（用户最常用、最关注的业务操作）然后基于场景获得其并发用户数。
javaScrip的学习（一）
weixin_65450681的博客
07-19 1318
这篇文章让我们简单来了解一下js，那么什么是js?JavaScript（简称JS）是一种高级编程语言，主要用于为网页添加交互功能。它可以嵌入到HTML页面中，通过对DOM（文档对象模型）的操作来实现动态效果和用户交互。JavaScript由Netscape公司的Brendan Eich于1995年创造，最初是为了增强HTML页面的功能性。随着时间的推移，JavaScript逐渐演变成一种通用的编程语言，可以在浏览器以外的环境中运行，例如服务器端的Node.js。
学习笔记---java篇（0723）
m0_70630166的博客
07-23 694
java、数据类型、循环、选择等
达梦数据库 CASE_SENSITIVE参数的理解
qq_44669390的博客
07-19 946
CASE_SENSITIVE
xxl-job拒绝访问
09-02
- *1* *2* [xxl-job服务端启动流程简记](https://blog.csdn.net/shark_chili3007/article/details/123343614)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt...
评论 17
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

敲代码的xiaolang

你的鼓励是我最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值