我的Java基础杂记

好长时间了,之前记的。用的着收好。

1.前++后++

自增运算符:++
自减运算符:--

基本含义:让一个变量涨一个数字1,或者让一个变量降一个数字1
使用格式:写在变量名称之前,或者写在变量名称之后。例如:++num,也可以num++
使用方式:
    1. 单独使用:不和其他任何操作混合,自己独立成为一个步骤。
    2. 混合使用:和其他操作混合,例如与赋值混合,或者与打印操作混合,等。
使用区别:
    1. 在单独使用的时候,前++和后++没有任何区别。也就是:++num;和num++;是完全一样的。
    2. 在混合的时候,有【重大区别】
        A. 如果是【前++】,那么变量【立刻马上+1】,然后拿着结果进行使用。    【先加后用】
        B. 如果是【后++】,那么首先使用变量本来的数值,【然后再让变量+1】。    【先用后加】
例如:// 与打印操作混合的时候
        int num2 = 20;
        // 混合使用,先++,变量立刻马上变成21,然后打印结果21
        System.out.println(++num2); // 21
        System.out.println(num2); // 21
        System.out.println("=================");
        
        int num3 = 30;
        // 混合使用,后++,首先使用变量本来的30,然后再让变量+1得到31
        System.out.println(num3++); // 30
        System.out.println(num3); // 31
        System.out.println("=================");

2.封g、s

封装中get、set方法中:
set是有参无返回值,并且是往里放。
get是无参有返回值,并且是往外拿。

3.Scanner、Random、ArrayList小杂


Scanner类是属于控制台输出,有普通的,和匿名的两种。
Random用来生成随机数字,其方法和Scanner方法一样,只是不带参数,还有在使用nextInt()是范围是正负21亿。
当nextInt(n)中有参数时就是代表随机数是一个左闭右开区间的范围(【0~n)范围也就是0~n-1)
ArrayList<String> list = new ArrayList<>();ArrayList集合,但凡在jdk1.7以上的版本后面的ArrayList<>都不用写参数,否则反之。
list.add( );这是增加索引,
list.get()从元素中获取
list.remove()从元素中删除元素
list.size()获取元素的长度

4.基本数据类型小杂


八个基本类中一般都是把首字母变成大写就变成包装类了,而int和char的包装类是特殊的,
int的包装类是Integer,char的包装类是Character.

5.字符串大杂


String 字符串中==是地址相等
例如: public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "abc";
        char[] charArray = {'a','b','c'};
        String str3 = new String(charArray);

        System.out.println(str1 == str2);//ture
        System.out.println(str1 == str3);//false
        System.out.println(str2 == str3);//false
    }
如果字符串是equals的话比较的是内容
例如: System.out.println(str1.equals(str2));//ture
        System.out.println(str1.equals(str3));//ture
        System.out.println(str2.equals(str3));//ture
但比较大小写的话就会是flase,其中如果是equalsIgnoreCase()就是ture,Ignore是忽略,Case大小写。
并且只有英文字母区分大小写,中文没有,会出现false.
例如:
        String strA = "Java";
        String strB = "java";

        System.out.println(strA.equals(strB));//严格区分大小写  false
        System.out.println(strA.equalsIgnoreCase(strB));// ture
String 当中与获取相关的常用方法
public int length()获取字符串中字符的个数
例如:
        int ch = "jfijfjfjfllf".length();
        System.out.println("字符串的长度是:"+ch);//出来长度12
public String concat( String str);将当前字符串和参数字符串拼接成返回值的字符串。
例如:
        String str1 = "Hello";
        String str2 = "World";
        String str3 = str1.concat(str2);

        System.out.println(str1);//Hello
        System.out.println(str2);//World
        System.out.println(str3);//HelloWorld
public char charAt(int indenx):查取指定索引位置的单个字符
例如:
char hh = "Hello".charAt(1);
        System.out.println("在字符串中第一个索引是:"+hh);//会把字符串中被索引的字母搜出来的,这个查询和
        //数组的查询方式一样按0.1.3.....de 方式
public int indexof(String str):查找参申诉字符串在本字符串当中首次出现的索引位置,如果没有返回-1值
例如:
  String str6 = "HelloWorld";
        int h = str6.indexOf("llo");
        System.out.println("第一次索引值是:"+h);//查找参数字符串在本来字符串中的第一索引位置


        int asd = str6.indexOf("asd");
        System.out.println("第一次索引值是:"+asd);//如果根本没有,返回-1值。
public String substring(int index):截取从参数位置一直到字符末尾,返回新字符串。
public String substring(int begin,int end):截取从begin开始end结束,中间的字符串。备注:【begin,end),包含左边,不包含右边。
例如:
 public static void main(String[] args) {
        String str1 = "HelloWorld";
        String sub = str1.substring(5);
        System.out.println(str1);
        System.out.println(sub);//World


        String sub2 = str1.substring(4, 7);
        System.out.println(sub2);//owo
    }
public char[ ] toCharArray():将当前字符串拆分成为字符数组作为返回值
public byte[ ] getBytes():获取当前字符串底层的字节数组。
public String replace( CharSequrnce oldString,CharSequence newString):
将所有出现的老字符串替换成为新字符串,返回替换之后的结果新字符串。
例如:
char[] ch = "Hello".toCharArray();
        System.out.println(ch[0]);
        System.out.println(ch.length);//5
        byte[] k = "ABC".getBytes();
        for (int i = 0; i < k.length; i++) {
            System.out.println(k[i]);//65.66.67
        }
        String str2 = "How do you do?";
        String he = str2.replace("o", "*");
        System.out.println(str2);//How do you do?
        System.out.println(he);//H*w d* y*u d*?
        String str3 = "雷吱木吱嘎,丢类老母";
        String ma = str3.replace("丢类老母", "****");
        System.out.println(ma);//雷吱木吱嘎,****
分割字符串的方法;
public String[] split(String regex):按照参数的规则,将字符串切分成为若干部分。
注意事项:split方法的参数其实是一个“正则表达式”,今后学习。
今天要注意:如果要按照英文句点"."进行切分,必须写“\\.(两个反斜杠)”

6.静态变量小杂


static静态关键字,在类中使用可属于每个对象,调用。
光标放在需要修改的变量名上,然后shift + F6~ 完美~
static静态方法不用创建对象可以直接调用,调用时一半建议用类名.方法名
无论是成员变量,还是成员方法。如果有了static,都推荐使用类名称进行调用。
静态变量:类名称.静态变量
静态方法:类名称.静态方法()  注意:静态方法中不能出现this对象
注意:静态不能访问非静态。原因:因为在内存当中是【先】有静态内容,【后】有的
非静态内容“古人不知今人,但今人知道古人”
static静态代码块,特点:当第一次用到本类时,静态代码执行唯一的一次。
静态内容总是优先于非静态,所以静态代码块比构造方法先执行。
(1):静态代码块的典型用途:
用来一次性地对静态变量进行赋值。
private int id()
private static int idCounter = 0;//学号计时器,每当new了一个新对象的时候,计数器++
public static String toString (数组):将参数组变成字符串,(按照默认格式:[元素1,元素2,元素3.......])
(2)public static void sort(数组):按照默认升序(从小到大)对数组元素进行排序。
例如:
 int[] str = {1,2,3};
        String s = Arrays.toString(str);
        System.out.println(s);//[1,2,3]

        int[] two = {3,2,4,5,1,9,8};
        Arrays.sort(two);
        System.out.println(Arrays.toString(two));//[1,2,3,4,5,8,9]
(3)java.util.math类是数学相关的工具类,里面提供大量的静态方法,完成与数学运算符相关的方法
public static double  abs( double num):获取绝对值。
public static double  ceil( double num):向上取整。
public static double  floor( double num):向下取整。
public static long  round(double num):四舍五入。
例如:System.out.println(Math.abs(3.14));//3.14
        System.out.println(Math.abs(-5.6));//5.6
        System.out.println(Math.ceil(3.9));//4.0
        System.out.println(Math.ceil(3.1));//4.0
        System.out.println(Math.ceil(-3.1));//-3.0
        System.out.println(Math.floor(3.9));//3.0
        System.out.println(Math.floor(3.1));//3.0
        System.out.println(Math.floor(-3.1));//-4.0
        System.out.println(Math.floor(-3.1));//-4.0
        System.out.println(Math.round(3.5));//4
        System.out.println(Math.round(3.1));//3
        System.out.println(Math.PI);//3.141592653589793


7.面向对象的三大特性:封装性、继承性、多态性。


继承是多态的前提,如果没有继承就没有多态。
在继承的关系中,“子类就是一个父类”。也就是说,子类可以被当做父类看待。
例如:父类是员工,子类是讲师,那么“讲师就是一个员工”。
在父子类的继承关系当中,如果成员变量重名,则创建子类对象时,访问有两种方式:
直接通过子类对象访问成员变量:
                     等号左边是谁,就优先用谁,没有则想上找。
简介通过成员方法访问成员变量:
                     该方法属于谁,就优先用谁,没有则向上找。
在父子关系中,创建子类对象,访问成员方法的规则:
                 创建的对象是谁,就优先用谁,如果没有则向上找。
例如:
public static void main(String[] args) {
        zi h = new  zi();
        h.methodzi();//子类构造方法。
        h.methodfu();//父类构造方法。
        h.method();  //子类构造方法。22
    }
重写(Override)
概念:在继承关系中,方法和名称一样,参数列表也一样。

重写(Override):方法的名称一样,参数列表【也一样】。最好叫覆盖、覆写
重载(Overload):方法名称一样,参数列表【不一样】。

方法的覆盖重写特点:创建的是子类对象,则优先用子类方法。
方法覆盖重写的注意事项:
1.必须保证父子类之间方法的名称相同,参数列表也相同。
@Overriad:写在方法前面,用来检测是不是有效的正确覆盖重写。
这个注解就算了,只要满足要求,也是正确的方法覆盖重写。

2.子类方法的返回值必须【小于等于】父类方法的返回值范围。
小扩展提示:java.lang.object类是所有类的公共最高类(祖宗类),java.lang.String
就是object的子类。

3.子类方法的权限必须【大于等于】父类方法的权限修饰符。
小扩展提示:public>protected>(default)>private
备注:(default)不是关键字ddefault,而是什么都不写,留空。
其中有一个super的用法,//把父类的show方法拿过来重复利用//自己子类在添加更多内容。

==============================
this和super两种构造调用,不能同时使用,还有它们都是也必须是构造方法的第一个语句,
唯一一个。在同一个调用中不会有第二个this和super。
=============================================
如何使用抽象类抽象方法:
1.不能直接创建new对象。
2.必须用一个子类来继承抽像父类。

接口:接口是一种公共的规范标准

接口中:抽象是abstract,默认是default,静态方法是static.
静态跟对象没关系,跟类有关系。
而且静态方法中:不能通过接口实现类的对象来调用接口当中的静态方法。
正确用法:通过接口名称,直接调用其中的静态方法。
格式:接口名称.静态方法名(参数)
接口也可以定义“成员变量”,但是必须使用public static final三个关键字
进行修饰。从效果上看,就是接口的常量。
格式:
public static final 数据类型 常量名称 = 数据值;
注意事项:
1.接口当中的常量,可以省略public static final ,注意:不写也一样。
2.接口当中的常量,必须进行赋值;不能不赋。

final 这是一个常量,一旦赋值,不可以修改。

多态:一个对象拥有多种形态,也就是:对象的多态性。
父类引用指向子类对象。

对象的向上转型就是:父类引用指向子类对象。
向上转型一定是安全的,没有问题的,正确的。但是也有一个弊端:

对象一旦向上转型为父类,那么就无法调用子类原本特有的内容。
ClassCastException类转换异常

8.数据结构

栈-----------这个结构就是先进后出。入口和出口在同一侧。

队列---------这个结构就是先进先出。入口和出口在两侧。

数组---------这个结构查询快,增删慢。
查询快:数组的地址是连续的,我们通过数组的首地址可以找到数组,通过数组的索引可以快速查找某一个元素
增删慢:数组的长度是固定的,我们想要增加/删除一个元素必须创建一个新数组,把源数组的数据复制过来
在堆内中,频繁的创建数组,复制数组中的元素,销毁数组,效率低下。

链表----------这个结构查询慢,增删快。
查询慢:链表中地址不是连续的,每次查询元素都必须从头开始查询。
增删快:链表结构,增加/删除一个元素,对链表的整体结构没有影响所以增删快。
链表分两种一种是单向链表,一种是双向链表。
单向链表:链表中只一条子链,不能保证元素的顺序(存储元素和取出元素的顺序有可能一致)
双向链表:链表中有两条链子,有一条链子是专门记录元素的顺序,是一个有序的集合。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

打赏作者

Ahu123.

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明:

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

余额充值