首页 > 编程语言 >java从入门到精通

java从入门到精通

时间：2024-06-17 11:36:06浏览次数：12  
标签：精通 java 入门 void System class println public out

java从入门到精通

1. 进制转换

1.1 二进制和十进制

image

1.2 八进制

image

package com.itheima.variable;

public class ASCIIDemo1 {
    public static void main(String[] args) {
        // 目标：掌握ASCII编码表的编码特点。
        System.out.println('a' + 10); // 97 + 10 = 107
        System.out.println('A' + 10); // 65 + 10 = 75
        System.out.println('0' + 10); // 48 + 10 = 58

        // 二进制 八进制 十六进制在程序中的写法。
        int a1 = 0B01100001;
        System.out.println(a1); //97

        int a2 = 0141;  // 0开头的数据当成八进制看待！
        System.out.println(a2); //97

        int a3 = 0XFA;  // 0X开头的数据是十六进制
        System.out.println(a3);
    }
}

1.3 十六进制

image

2. 类型及转换

2.1 基本数据类型

image

1字节等于8位（2进制)

2.2 自动类型转换

image

package com.itheima.type;

public class TypeConversionDemo1 {
    public static void main(String[] args) {
        // 目标：理解自动类型转换机制。
        byte a = 12;
        int b = a; // 发生了自动类型转换了
        System.out.println(a);
        System.out.println(b);

        int c = 100; // 4
        double d = c;// 8 发生了自动类型转换了
        System.out.println(d);

        char ch = 'a'; // 'a' 97 => 00000000 01100001
        int i = ch; // 发生了自动类型转换了 =>  00000000 00000000  00000000 01100001
        System.out.println(i); //97
    }
}

image

3. 数组

3.1数组在内存中的执行原理

image

image

image

image

image

4. 方法

4.1在内存中的执行原理

image

image

4.2 java中的方法传递

image

4.2.1 基本数据类型传递

package com.itheima.parameter;

public class MethodDemo1 {
    public static void main(String[] args) {
        // 目标：理解方法的参数传递机制：值传递。
        int a = 10;
        change(a); // change(10);
        System.out.println("main:" + a); // 10
    }

    public static void change(int a){
        System.out.println("change1:" + a); // 10
        a = 20;
        System.out.println("change2:" + a); // 20
    }
}

4.2.2 引用数据类型传递

image

package com.itheima.parameter;

public class MethodDemo2 {
    public static void main(String[] args) {
        // 目标：理解引用类型的参数传递机制：值传递的。
        int[] arrs = new int[]{10, 20, 30};
        change(arrs);
        System.out.println("main:" + arrs[1]); //222
    }

    public static void change(int[] arrs){
        System.out.println("方法内1：" + arrs[1]); //20
        arrs[1] = 222;
        System.out.println("方法内2：" + arrs[1]); //222
    }
}

5. 对象

5.1 对象在内存中的执行原理

image

image

5.2 this的执行原理

image

5.3 static的用法

image

5.4 成员变量的执行原理

image

5.5 成员方法

image

image

image

image

5.6 静态代码块

image

image

5.7 实例代码块

image

image

6. string

image

image

image

image

image

image

image

7. 继承

image

7.1 继承的执行原理

image

7.2 权限修饰符

image

image

image

7.3 子类构造器

image

image

7.4 final

image

package com.itheima.d3_final;
 
public class Test {
    /**
     * 常量： public static final修饰的成员变量，建议名称全部大写，多个单词下划线连接
     */
    public static final String SCHOOL_NAME = "黑马";
    private final String name = "猪八戒"; // 这种用法没有意义，知道就行
 
    public static void main(String[] args) {
        // 目标：认识final的作用。
        // 3、final可以修饰变量总规则：有且仅能赋值一次
        /* 变量：
            一，局部变量
            二，成员变量
                1、静态成员变量
                2、实例成员变量
        */
        final int a;
        a = 12;
        // a = 13; // 第二次赋值，出错了
 
        final double r = 3.14;
        // r = 0.1; // 第二次赋值，出错了
 
        final int[] arr = {11, 22, 33};
        // arr = null; // 第二次赋值，出错了
        arr[1] = 222;
 
        // schoolName = "白马"; // 第二次赋值，出错了
        Test t = new Test();
        // t.name = "孙悟空";// 第二次赋值，出错了
    }
 
    public static void buy(final double z){
        // z = 0.1;// 第二次赋值，出错了
    }
}
 
// 1、final修饰类，类不能被继承了
final class A{}
//class B extends A{}
 
// 2、final修饰方法，方法不能被重写了
class C{
    public final void test(){
    }
}
class D extends C{
//    @Override
//    public void test() {
//
//    }
}

image

final int[] arr = {11, 22, 33};
// arr = null; // 第二次赋值，出错了，final修饰地址不能改变
arr[1] = 222; //值是可以改变的

image

image

8. 抽象类

image

image

8.1 模板方法设计模式

image

image

image

9. 接口

image

image

jdk 8 之后接口新增了三种方法

image

package com.itheima.d10_interface_jdk8;

public interface A {
    /**
     * 1、默认方法：必须使用default修饰，默认会被public修饰
     * 实例方法：对象的方法，必须使用实现类的对象来访问。
     */
    default void test1(){
        System.out.println("===默认方法==");
        test2();
    }

    /**
     * 2、私有方法：必须使用private修饰。(JDK 9开始才支持的)
     *   实例方法：对象的方法。
     */
    private void test2(){
        System.out.println("===私有方法==");
    }

    /**
     * 3、静态方法：必须使用static修饰，默认会被public修饰
     */
     static void test3(){
        System.out.println("==静态方法==");
     }

     void test4();
     void test5();
     default void test6(){

     }
}

10. 内部类

image

image

10.1 成员内部类

image

image

package com.itheima.d1_inner_class1;

public class Outer {
    private int age = 99;
    public static String a;
    // 成员内部类
    public class Inner{
        private String name;
        public static String schoolName; // JDK 16开始才支持定义静态成员的
        private int age = 88;

        public void test(){
            System.out.println(age); //内部类可以访问外部类的成员变量
            System.out.println(a);

            int age = 66;  //内部类、外部类变量名相同，如何访问
            System.out.println(age);// 66
            System.out.println(this.age);// 88
            System.out.println(Outer.this.age);// 99
        }

        public String getName() {
            return name;
        }

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

    public void test2(){
        System.out.println(age);
        System.out.println(a);
    }
}

package com.itheima.d1_inner_class1;

public class Test {
    public static void main(String[] args) {
        // 目标：了解成员内部类和其特点。
        Outer.Inner in = new Outer().new Inner();
        in.test();
    }
}

10.2 静态内部类

image

package com.itheima.d2_inner_class2;

public class Outer {
    private int age = 99;
    public static String schoolName;
    // 静态内部类
    public static class Inner{
        private String name;
        public static int a;
        private int age = 88;

        public void test(){
            System.out.println(schoolName);
            // System.out.println(age); //静态内部类与静态方法类似，只能访问外部类的静态成员变量，										  //不能访问实例变量
        }

        public String getName() {
            return name;
        }

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

    public static void test2(){
        System.out.println(schoolName); //静态方法只能访问静态成员变量
        // System.out.println(age); //静态方法不能访问实例变量
    }
}

package com.itheima.d2_inner_class2;

public class Test {
    public static void main(String[] args) {
        // 目标：了解静态内部类。
        Outer.Inner in = new Outer.Inner();
        in.test();
    }
}

10.3 局部内部类

image

10.4 匿名内部类

image

利用之前的子类去实现功能

package com.itheima.d3_inner_class3;

public class Test {
    public static void main(String[] args) {
        // 目标：认识匿名内部类，并掌握其作用。
        Animal a = new Cat();
        a.cry();
    }
}

class Cat extends Animal{
    @Override
    public void cry() {
        System.out.println("猫喵喵喵的叫~~~");
    }
}

abstract class Animal{
    public abstract void cry();
}

利用匿名内部类实现该功能

package com.itheima.d3_inner_class3;

public class Test {
    public static void main(String[] args) {
        // 目标：认识匿名内部类，并掌握其作用。
        // 1、把这个匿名内部类编译成一个子类，然后会立即创建一个子类对象出来。
        Animal a = new Animal(){
            @Override
            public void cry() {
                System.out.println("猫喵喵喵的叫~~~");
            }
        };
        a.cry();
    }
}


abstract class Animal{
    public abstract void cry();
}

10.5 匿名内部类的使用场景

image

package com.itheima.d3_inner_class3;

public class Test2 {
    public static void main(String[] args) {
        // 目标：掌握匿名的常见使用场景。
//        Swimming s1 = new Swimming(){
//            @Override
//            public void swim() {
//                System.out.println("狗

标签：精通,java,入门,void,System,class,println,public,out	

From： https://www.cnblogs.com/xinmomoyan/p/18252040

相关文章

  • Java常见面试题分享-用Java实现LIS(最长递增子序列)算法
    问题描述编写一个函数，该函数接受一个整数列表作为参数，计算这个列表的最长递增子序列(LIS)的长度，这个也是动态规划中常见的问题。举一个典型的场景：用来查找股票价格的最大增长，比如股票价格是[12,13,11,14,15,16,10,9,8,7]，股票价格的最大增长是[12,13,14,15,......
  • 持续性学习-Day18（JavaWeb）
    JavaWeb1、基本概念web开发：web，表示可以从互联网上拿到一定的资源静态webhtml、css提供给所有人看的数据，始终不会发生变化动态web每个人在不同时间、不同地点，看到的信息各不相同技术栈：servlet/JSP、ASP、PHP在Java中，动态web资源开发的计数统称为Java......
  • JavaScript 面试问题及答案
    什么是JavaScript模块？答： JavaScript模块是可重复使用的代码片段，可以在文件之间导入和导出，从而提高模块化和可维护性。解释原型链的概念。答：原型链是JavaScript中的一项功能，它允许对象通过原型链从其他对象继承属性和方法。什么是高阶函数？答：高阶函数是可以将其他函数作......
  • 将本地jar引入到java工程中的三种方式
    方式一、IDEA->File->ProjectStructure->Modules->Dependencies->+->JARsorDirectories方式二、如要添加的jar文件较多，可创建目录，例：resources->libs，然后用方式一，选择此目录。方式三、如果项目是maven工程，可以通过修改pom文件，将本地jar引用工程中，如下所示<depende......
  • 高级前端的 25 个常用 JavaScript 单行代码
    1.不使用临时变量来交换变量的值例如我们想要将 a 于 b 的值交换leta=1,b=2;//交换值[a,b]=[b,a];//结果:a=2,b=1这行代码使用数组解构赋值的方式来交换两个变量的值，无需定义新的临时变量。这个巧妙的技巧可让代码看起来更简洁明了。语法[a,b......
  • Java的I/O模型
    Java的I/O发展简史从JDK1.0到JDK1.3，Java的I/O类库都非常原始，很多UNIX网络编程中的概念或者接口在I/O类库中都没有体现，比如Pipe、Channel、Buffer和Selector等。2002年发布JDK1.4时，NIO以JSR-51的身份正式随JDK发布。它新增加了java.nio包，提供了很多进行异步I/O开发的API和类库......
  • 浅拷贝、深拷贝与序列化【初级Java必需理解的概念】
    浅拷贝首先创建两个类，方便理解浅拷贝@DataclassStudentimplementsCloneable{//年龄和名字是基本属性privateintage;privateStringname;//书包是引用属性privateBagbag;publicStudent(intage,Stringname,Bagbag){this.......
  • Java 6.16 DeepClone and ShallowClone
    浅克隆：复制对象的引用地址，导致克隆对象和原始对象共享引用类型字段的实际对象。classPersonimplementsCloneable{Stringname;Addressaddress;publicPerson(Stringname,Addressaddress){this.name=name;this.address=add......
  • Java - function
     Java-Assignment04(100pts)InstructionsWriteeachexerciseinitsownmethod.Uncommentthefunctioncallsinmain()toactivateeachexercise.Referto"Assignment01"ifnecessary.Foreachexercise,usecommentstowritepseudocodew......
  • 面试官：Java中缓冲流真的性能很好吗？我看未必
    一、写在开头上一篇文章中，我们介绍了JavaIO流中的4个基类：InputStream、OutputStream、Reader、Writer，那么这一篇中，我们将以四个基类所衍生出来，应对不同场景的数据流进行学习。二、衍生数据流分类我们上面说了java.io包中有40多个类，都从InputStream、OutputStream、Reader、Wr......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99