Java基础--小整合方便随时看的

java基础

数据类型Basic ，String

java整形浮点型细节

package week01;
​
public class intDetail {
    public static void main(String[] args) {
​
        int n1 = 1;
        //int n2 = (int) 1L;
        long n3 = 1L;
​
        //bit是最小的存储单元，byte是一个字节也就是基本存储单元
        //社会是由人类构成的，但是人类是由细胞构成的
        //以前我总是认为字节是要相加的，一直没有改过，啊哈哈，
        byte m1 = 1;
        short m2 = 1;
​
​
    }
}
​
package week01;
​
public class floatDetail {
​
    public static void main(String[] args) {
        //浮点数是由符号位 + 指数位 + 尾数位
​
        //java中浮点数默认是double，如果是float类型 需要加f
        float a = 1.1f;
        double b = 1.5;
        double c = .123;
​
​
        //一般不可以用浮点数运算来进行比较
        double d = 2.7;
        double f = 8.1/3;
        System.out.println(d + "  " + f);
​
        //解决办法
        if(Math.abs(d - f) < 0.00001) System.out.println("相等");
    }
​
}
​

java字符型细节

package week01;
​
public class chatDetail {
​
    public static void main(String[] args) {
​
        char c = 97;
        //char a = "8";”“字符串类型 ‘’字符类型
        System.out.println(c);
​
        //在java中char本质的整数，对用的是unicode码对应的字符
        char c1 = 33889;
        System.out.println(c1);
        char c2 = '葡';
        System.out.println((int)c2);
​
        //char 可以进行运算的
        System.out.println((char) ('a' + 10));
​
    }
​
}
​

image-20220418160821880

 

boolean类型

boolean不能直接等于0，1只能是true，flase

基本数据类型转换

自动类型转换，java中精度小的数据类型可以自动转化为精度大的数据类型

char - int - long - float - double

byte - short - int-long - float - double

int a = 'c';//OK

细节

package week01;
​
public class AutoConvert {
​
    public static void main(String[] args) {
        int num = 'A';
        double a = 80;
        System.out.println(num + "  " + a);
​
        //1.把数字赋值给byte时候，先判断数字是不是在byte范围之内
        byte b = 15;
        //2.byte,short 不会和 char 发生转换
        //char c = b;  错误
​
        //3.byte short char 他们三者在计算的时候首先会转化为int,
        byte d = 1;
        short f = 1;
        //short e =  (d + f);
        int e = d + f;
​
​
        byte g = 1;
        //byte k = d + g;同种类型的也不行！！！！！
        int k = d + g;
​
        //4.boolean 不参与转换
        //java中boolean true ，flase，一般就作为条件，不会像c++那样可以是0，1还能参与运算
        boolean l = true;
        //int c = 1 + l;错
​
        //5.自动提升原则，转换成精度最大的
​
    }
​
}
​

 

强制类型转换

package week01;
​
public class ForceConvert {
​
    public static void main(String[] args) {
​
        //1.并不会变成最大的数字,数据溢出了
        int a = 200000;
        byte b = (byte) a;
        System.out.println(b);
​
        //2.精度减小
        double c = 1.1;
        int d = (int) c;
        System.out.println(d);
​
        //3.强转（）就近原则
        //int f = (int)3.5 * 6 * 3.2;只是把3.5转换成3了并没有把3.2转换所以还是double类型
        int f = (int)(3.5 * 6 * 3.2);
        System.out.println(f);
​
        //4.char类型可以保存int常数值，但不能保存int变量值，只能强转！
        char g =100;
        int k = 100;
        char p = (char) k;
        int m = g;
        System.out.println(p + "   " + m);
    }
​
}
​

基本数据类型练习题

image-20220418193236924

String和Basic的转换

package week01;
​
public class StringToBasic {
​
    public static void main(String[] args) {
        //1.basic -> string
        int a = 2;
        char b = 100;
        short c = 200;
        double d = 1.1;
        String a1 = a + "";
        String b1 = b + "";
        String c1 = c + "";
        String d1 = d + "";
        System.out.println(a1 + " " + b1 + " " + c1 + " " + d1);
​
        //2.string -> basic
        String s1 = "112";
        int num = Integer.parseInt(s1);
        double m = Double.parseDouble(s1);
        System.out.println(num + " " + m);
        for(int i = 0; i < s1.length(); i ++)
        {
            char t = s1.charAt(i);
            System.out.println(t);
        }
​
    }
​
}
​

（// - > /）

运算符

算数运算符

package week01;
​
public class Operator {
​
    public static void main(String[] args) {
        //最高精度都是int 所以 答案是2
        System.out.println(10/4);
        //高度精度还是int但是算完了还要赋值给double类型所以是2.0
        double d = 10/4;
        System.out.println(d);
​
        //在java % 的本质是 a - a / b * b;
        // a/b除数 再*b就是除去了多少的数字，最后用总数减去就是余数
        //-10.5 % 3 = -10.5 - （int）(-10.5)/3 * 3 = -1.5
        //有小数运算的时候结果是近似值
        System.out.println(10%3);
        System.out.println(-10%3);
        
        
        //10 - 10/(-3)*(-3)
        System.out.println(10%-3);
        System.out.println(-10%-3);
        //总结前面的如果是负数拿结果就是负数，因为你a-(...)，a是绝对值最大的哇，怎么都掰不过来的
​
        //自增表达式
        int j = 8,i = 8;
        int k = j++;//k = j,j = j + 1;
        int h = ++i;//i = i + 1,h = i;
        System.out.println(k + "    " +h);
​
        //练习题
        int p = 1;
        p = p ++;//p = 1,p = p + 1  ×
        //程序执行的时候会有一个temp，temp = p,p = p + 1;p = temp;
        System.out.println(p);
​
        int g = 1;
        g = ++g;//g = g + 1,temp = g,g = temp;
        System.out.println(g);
​
​
    }
​
}
​

关系运算符

image-20220419144603744

逻辑运算符号

 

package week01;

public class LogicOperator {

    public static void main(String[] args) {
        //短路与，逻辑与
        int a = 1;
        int b = 9;
        if( a > 5 && ++b < 5)
        {
            System.out.println("OK111");
        }
        System.out.println("a = " + a + "b = " + b);
        if(a > 5 & ++b < 5)
        {
            System.out.println("OK222");
        }
        System.out.println("a = " + a + "b = " + b);
        //两者的虽然都可以进行判断但是短路呢短路，一个不通过就直接短路不运行了，但是&不是这样子的他是都进行判断不会终止的

        //短路或者，逻辑或
        int c = 1;
        int d = 9;
        if( c < 5 || ++d < 5)
        {
            System.out.println("OK333");
        }
        System.out.println("c = " + c + "d = " + d);
        if(c < 5 | ++d < 5)
        {
            System.out.println("OK444");
        }
        System.out.println("c = " + c + "d = " + d);
        //还是相同道理短路或判断完第一个如果正确就不判断了


        //^逻辑异或
        //相等就是false，不相等是true
        System.out.println((10 > 1) ^ (1 > 6));
    }

}

image-20220419151931138

 

赋值运算符

public static void main(String[] args) {

        //复合运算符可以自动转换数据类型
        byte b = 2;
        b += 2;
        //等价于b =(byte)(b + 2);
        System.out.println(b);
    
    //包括b++也是同理底层有一个类型转换
    }

三元运算符

package week01;

public class TernaryOperator {
    public static void main(String[] args) {
        int a = 10;
        int b = 99;
        int res = a > b ? a++ : b--;//等于了99，然后才是b = b - 1;
        //三元运算的话还是得运算的不会终止的
        System.out.println(res + "   " + b + "  " + a);

        //三元运算符底层就是if else 语句 ，你可以想一想if else语句肯定判断完了之后执行条件下的语句
        int l = (int) (a > b ? 1.1 : 3.4);
        System.out.println(l);
    }
}

运算符优先级

image-20220419160524571

标识符

image-20220419161316667

 

进制+位运算

package week01.进制and位运算;

public class BinaryTest {

    public static void main(String[] args) {
        int n1 = 0b1010;//2进制
        int n2 = 01010;//8
        int n3 = 1010;//10
        int n4 = 0X1010;//16
        System.out.println(n1);
        System.out.println(n2);
        System.out.println(n3);
        System.out.println(n4);

        //x进制转换为10进制
        //公式....


        //10进制转换x进制
        //辗转相除法
        
    }

}

原码，反码，补码

![image-20220419165750722](存放typora图片/image-20220419165750722.pngimage-20220419165759935

java中有7个位运算符号（^,&,|,~,<<,>>,>>>）

package week01.进制and位运算;

public class 原码反码补码 {

    public static void main(String[] args) {
        int a = 2;
        int b = 3;
        System.out.println(a & b);
        System.out.println(a | b);
        System.out.println(a ^ b);
        System.out.println(~a);
        System.out.println(~b);
    }

}
2原码 00000000 00000000 00000000 00000010
因为2是正数三码合一
对于2取反
      11111111 11111111 11111111 11111101 补码
这个就变成负数了 补码 = 反码 + 1
所以反码就是
	11111111 11111111 11111111 11111100
求出原码
    10000000 00000000 00000000 00000011
    就是-3
    
1.正数三码合一
2.运算用补码运算
3.负数的时候补码 = 反码 + 1;
4.第一位（符号位）0表示整数 1表示负数
5.负数原码跟反码，符号位不变，其余变成相反的

控制结构

switch

package week01.循环;

public class SwitchDetail {

    public static void main(String[] args) {
        //1.
        //表达式数据类型，应该和case后面的类型一样
        //如果不一样 那就是可以自动转换的  但是字符和字符串就不可以转换

        //2.
        //switch表达式类型必须是int short byte string char enum
        //double是不行的！！！

        //3.
        //switch语句中case只能是常量不能是变量

        //4.
        //switch的方式是先执行第一个case语句，然后如果没有break就继续执行，直到执行结束
        char c = 'a';
        switch(c)
        {
            case 'a' :
                System.out.println(111);

            case 'c':
                System.out.println(222);
                
            default:
                System.out.println(333);
                break;
        }
    }
}

for

 

 

 

while

image-20220420191337931

while里面是条件的，c++中while（1）在java中就不可以，只能while（true）

 

 

do while

 

break细节

package week01.循环;

public class BreakDetail {
    public static void main(String[] args) {
        abc:
        for(int i = 0; i < 4 ; i++)
        {
            System.out.println("i = " + i);
            bcd:
            for(int j = 0; j < 4; j ++)
            {
                if(j == 2)
                {
                    break abc;
                }
                System.out.println("j = " + j);
            }
        }
    }
}

continue

package week01.循环;

public class ContinueDetails {
    public static void main(String[] args) {
        abc:
        for(int i = 0; i < 4 ; i++)
        {
            System.out.println("i = " + i);
            bcd:
            for(int j = 0; j < 4; j ++)
            {
                if(j == 2)
                {
                    continue abc;
                }
                System.out.println("j = " + j);
            }
        }
    }
}

continue的意思就是跳出当前的循环然后继续进行下一层的循环，自己continue acb和bcd就可以明白什么意思了

 

return

表示跳出这个方法，如果在主程序就是跳出主程序

 

引用数据类型：数组

image-20220420194812292

package week01.数组;

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

        //拷贝赋值
        int n = 10;
        int m = n;
        m = 80;
        System.out.println(m);

        //引用赋值
        int a[] = {1,2,3};
        int b[] = a;

        b[2] = 5;
        for(int i = 0; i < 3; i ++)
            System.out.println(a[i]);
    }
}

冒泡

package week01.数组;

public class 冒泡 {
    public static void main(String[] args) {
        int a[] = {1,5,6,9,8};

        for(int i = 0; i < a.length - 1; i ++)
        {
            for(int j = 0; j < a.length - i - 1; j ++)
            {
                if(a[j] > a[j + 1])
                {
                    int temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }

        for(int i = 0; i < a.length; i ++)
        {
            System.out.println(a[i]);
        }
    }
}

二维数组内存分布

image-20220421160615981

image-20220421161034104

面向对象编程

类和对象

image-20220421162155926

//知道怎么写就行了
class cat
{
 String name;
 String color;
 int age;
}

简单分析一下：

new 一个cat 在栈中（对象引用名），栈中有一个地址，会在堆区中对应，该堆区就会有一个对象，对象里面有中有三个成员变量，但是String类型不是基本数据类型，属于引用数据类型，所以在方法区展示

 

image-20220421163522433

最开始new person 直接会在堆区中占用一个地址，里面有age=10，但是String不是基本数据类型需要在方法区调用，然后将new的person 引用对象名称叫p1，然后栈区就会生成一个找到堆区的地址，然后经行下面两句的赋值，最后说明一下p2 = p1是直接指向p1

 

下面代码用Cat类比Person

package week01.类与对象;

public class Object01 {

    public static void main(String[] args) {
        cat cat = new cat();
        cat.age = 10;
        cat cat1 = new cat();
        cat1 = cat;

        System.out.println(cat1.age);
    }
    
}
//知道怎么写就行了
class cat
{
    String name;
    String color;
    int age;
}
练习题

image-20220421165312448

因为b已经断掉了

成员方法细节

访问修饰符：public ，protect， 默认，private 四种

方法在返回的时候会有自动类型的转换

public double a()
{
	int n = 100;
	return n;//int -> double
}

你调用方法的时候也可以兼容的也是低精度到高精度

package week01.类与对象;

public class Object01 {

    public static void main(String[] args) {
        cat cat1 = new cat();
        short b = 20;
        cat1.a(20);
    }

}

class cat
{
    public void a(int n)
    {
        System.out.println(n);
    }
}

重载

方法名相同，但是传递的参数是不一样的

image-20220422081808415

可变参数使用
package week01.重载;

public class OverLoad {
    public static void main(String[] args) {
        T t = new T();
        t.sum(1,5,6,8);
    }
}
class T{
    public int sum(int... nums)
    {
        System.out.println(nums.length);
        return  0;
    }
}

int... 是可以变化的参数，可以把nums当成数组使用

1.一个函数只能有一个可变参数

2.可以和普遍类型的放一起，但是要放在最后面

构造器

image-20220424094436538

package week01.构造器;

public class this01 {
    public static void main(String[] args) {
        dog dog = new dog();
        dog.tt("王骜",6);
        int i = dog.hashCode();
        System.out.println(i);
    }
}
class dog{
    String name;
    int age;
    //hashCode是返回的一个哈希码，是把其中的内存地址转换为哈希码
    //来证明this指向的确实是自己的堆
    public void tt (String name,int age)
    {
        this.age = age;
        this.name = name;
        int i = this.hashCode();
        System.out.println(i);
    }
}
构造器细节

1.构造器访问另一个构造器只能采用this的方法

package week01.构造器;

public class thisDetails {
    public static void main(String[] args) {
        a a = new a();
    }
}
class a {
    String name;
    String pwd;
    public a()
    {
        //必须放在最前面
        this("1","2");
        System.out.println("空构造");
    }
    public a(String name,String pwd)
    {
        System.out.println("有参构造");
    }
}

面向对象编程（中）

包

java导包注意，一定主要好导入的是哪一个的包

访问修饰符

image-20220424104945516

2.public修饰类的时候在一个类的最外面只能有一个，这个类就是java的文件名称，主类中可以有public class类，与主类同一级别的只能没有public才可以

封装

1.将属性私有化，不能直接修改属性

2.用一个public的set方法，来实现属性的赋值

3.用get方法来提取属性的值

package week02.封装;

public class Encape01 {
    public static void main(String[] args) {
        person person = new person();
        person.setAge(50);
        System.out.println(person.getAge());
    }
}
class person
{
    public String name;
    private int age;
    private double salary;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age >= 0 && age <= 100)
        {
            this.age = age;
        }
        else {
            this.age = -1;
            System.out.println("年龄不正确");
        }


    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

但是如果引入构造器的话，你的private就直接失效了

解决办法：可以把set方法写在构造器中。

public person(String name, int age, double salary) {
        /*this.name = name;
        this.age = age;
        this.salary = salary;*/
        
        setAge(age);
        setName(name);
        setSalary(salary);
    }

延续上面的代码直接在set当中增加判断即可

image-20220425091051056

 

但是一般会拆开写在业务逻辑中

 

继承

1.子类继承所有属性和方法，但是私有的属性和方法不能直接访问，只能在父类公有的方法中进行访问

2.先调用父类，再调用子类，子类必须调用父类构造器，完成初始化

子类隐藏了super（）

3.但是父类没有构造器的时候是子类在被创建的时候会编译器会生成一个无参构造，但是父类只有有参构造的时候，是不可以直接用子类来调用的，子类会找不到的，必须在super（）中指定一个！！

4.super（）放在构造器第一行// 先有爸再有儿子，this，super都需要放在构造器第一行//两个方法是不能共存的！！！

image-20220425151315113

image-20220425151350703

继承本质：

 

image-20220426091728434

image-20220426091743099

 

 

image-20220426092627657

 

package week02.继承;

public class EntendsThrond {
    public static void main(String[] args) {
        son son = new son();
        System.out.println(son.name);
        System.out.println(son.age);
    }
}
class pa
{
    public String name = "pa";
    public String hobby = "爬山";
}
class fa extends pa
{
    public String name = "fa";
    public int age = 50;
}
class son extends fa
{
    //public String name = "son";
}

1.如果子类中有对应的值，并且可以访问直接输出子类的，如果子类中没有就会去父类中访问有没有，有的话是不是可以访问，没有的话再去父类的父类去查找！！

 
posted @ 2022-04-26 09:34  爽爽子的秃头生活  阅读(149)  评论(0)    收藏  举报