黑马java阿伟ppt 黑马java笔记

转载

mob64ca1410eb61 2023-10-27 08:50:08

文章标签 黑马java阿伟ppt java 开发语言 System 父类 文章分类 Java 后端开发

局部变量没有默认值，需手动赋值，而成员变量和数组都有默认值；方法里的参数就是局部变量

1。short,byte,char 可做运算，做运算时（变量相加时），都会先转换成int 加完后的结果就是int型；同时，赋值时（也可用于常量相加，即常量优化），如果右侧的范围小于左侧的范围，编译器会自动帮你转换（右侧前面加个（byte)(short)(char),若超过范围，就报错

黑马java阿伟ppt 黑马java笔记_System

黑马java阿伟ppt 黑马java笔记_java_02

2.虽然Long是8字节，float是4字节，但是float的范围比long要大

3.+再字符串中使用表示连接操作，任何类型的数据和String相加，结果都会变成字符串

4逻辑运算符的短路原则：当左边的已经能判断最终结果，符号右边的就不会执行，节省时间提高性能

5，switch一定要有break

6，IDE中的快捷键 ctrl+y:删除当前行 ctrl+d:增加一行 ctrl+alt+l :格式化代码 alt+shift+上下箭头：代码上下移动（不需要cv） ctrl+alt+v 生成左边内容

alt+/ enter :导入包 shift+F6统一重命名

7.project--module--src中新建package--java class

8.System.out.println(); 其中ln是换行，去掉就不换行System.out.print();

9。 5.fori 快速写入for循环 数组名称.fori 可得数组长度的for循环

10.方法的重载（overload)：方法名可相同，但参数列表不同，不同的参数（个数，类型，排列顺序）调用不同的重名方法（自动找参数对应的方法）

11.创建动态数组（指定长度）（会有默认值） int[] arrayA = new int[300]; String[] arrayB = new String[10];

12.创建静态数组（指定内容） int[] arrayC = {5,10,15,20}; String[] arrayD ={"Hello","Hi"};

13.int[] arrayB = new int[3]; int[] arrayC = arrayB; 就是把B数组的首地址给C，C与B同时指向同一个内存空间

14.数组是引用数据类型 int[] arrayC = null; 可以赋值为null 代表什么都没有 int[] arrayC = null; arrayC = new int[3]; 补上new就行

15.数组作为参数传递（传递的是数组的地址值）时，传递格式就是数组类型[] 数组名调用时（）中加上数组名

16.作为返回值时，返回数组名，方法中数据格式是数组类型[]

17.成员方法不用写static

18.创建对象：类名称对象名 = new 类名称（）; Lei stu = new Lei(); 调用的话就是对象名.变量（或者方法（可能要传参数））

19.类中的对象也可以作为方法的参数（传递的是对象的地址）（类名对象名） Phone nihao = new Phone();

method(nihao);        public static void method(Phone(类名) nibuhao（对象名）) {System.out.println(nibuhao.brand);}

20，类中对象也可以作为return 返回的内容， 返回值类型为类名

21.类中属性用private修饰（private int age;封装保护作用，提高安全性）本类中可直接访问，其他对象得用set 方法（无返回值，有参数）和 get 方法（无参数，有返回值，类型和成员变量类型一致）间接访问这两种方法都是定义在类中的方法

对于boolean类型，get方法变成is方法，set方法不变

22.当方法的参数和成员变量同名时，就近原则，优先使用方法参数，如果想使用本类的成员变量，加个关键字this.成员变量 （起重名区分作用）（对象调用，对象就是this）

23.构造方法是专门用来创建对象时使用的方法（new创建对象时，就是在调用构造方法）（构造方法可多个，即构造方法也可以重载）

注：格式：public 类名(参数类型参数名称) { } 不要写返回值

24.alt+insert 构造标准的类

25.对象数组存的是对象的地址

Person[] array = new Person[3];
System.out.println(array[0]);         //null
Person one = new Person("java",12);
array[0] = one;
System.out.println(array[0].getName());   //java

26,数组集合(也可以作为方法的参数 ArrayList<E> 集合名） 相当于py中的列表

import java.util.ArrayList;        
        //<>中只能是引用类型,不能是基本类型
        ArrayList<String> list = new ArrayList<>();
        System.out.println(list);//[]
        list.add("nihao");//增,boolean类型的返回值代表是否成功
        list.add("nih");
        list.add("ni");
        int size = list.size();
        System.out.println(size);
        String name = list.get(1);
        System.out.println("第二个元素"+name);
        String removeName = list.remove(2);
        System.out.println(list);

集合名.fori 得到for (int i = 0; i < list.size(); i++)

27.当要在数组集合中使用基本类型时，必须使用“包装类”（除了Int--Integer,char--character外，其他包装类首字母都大写即可)

ArrayList<Integer> listA = new ArrayList<>();
listA.add(100);
int num = listA.get(0);
System.out.println(num);

28.数组集合作为返回值和参数

public static ArrayList<Integer> littleArrayList(ArrayList<Integer> list){
        ArrayList<Integer> smallList = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            if(list.get(i) % 2 == 0 ) {
                smallList.add(list.get(i));
            }
        }
        return smallList;
    }

ArrayList<Integer> smallList = littleArrayList(list);    主方法创建一个数组集合用来接收返回值

29.字符串的内容不可改变

30，对于引用型变量，== 是进行地址值比较；对于基本类型变量，==是进行数值的比较

//字符串内容比较       直接创建的字符串本身就是一个对象
        String str1 = "Hello";
        String str2 = "Hello";
        System.out.println(str1.equals(str2));
        //格式推荐 常量字符串写在前面，对象写在后面
        //严格区分大小写
        System.out.println("Hello".equals(str2));
        //不区分英文字母大小写
        System.out.println("hello".equalsIgnoreCase(str1));
        //获取字符串的长度 length
        System.out.println(str1.length());
        //拼接字符串,返回值是一个新的字符串，因为字符串的内容是不会变化的  concat
        System.out.println(str1.concat(str2));
        //获取指定索引位置的单个字符，返回值是一个字符   charAt
        System.out.println(str1.charAt(1));
        //查找参数字符串再本来字符串当中出现的第一次索引位置，没有返回-1  indexof
        System.out.println(str1.indexOf("llo"));
        //字符串的截取   两种，重载
        String str3 = "HelloWord";
        System.out.println(str3.substring(5));//索引到末尾结束
        System.out.println(str3.substring(2,5));//[)
        //将当前字符串拆分成为字符数组作为返回值
        char[] chars = "Hello".toCharArray();
        System.out.println(chars.length);
        //转换成字节数组
        byte[] bytes = "abc".getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.print(bytes[i]);//97 98 99
        }
        System.out.println("========");
        //替换
        String str4 = "How do you do?";
        String o = str4.replace("o", "*");
        System.out.println(o);
        //分割字符串
        String str5 = "aaa,bbb,ccc";
        String[] array1 = str5.split(",");
        System.out.println(array1);
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i]);
        }
        //英文的.必须用\\.来切
        String str6 = "aaa.bbb.ccc";
        String[] array2 = str6.split("\\.");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i]);
        }

32.一旦使用了static关键字，这样的内容就不属于对象自己，而是属于整个类，是共享的

public class Demo01 {
    private String name;
    private int id;
    private int age;
    static int classNum ;//修饰变量
    private static int stuNum = 0;

    public Demo01() {
        ++stuNum;
    }

    public Demo01(String name, int age) {
        this.name = name;
        this.age = age;
        this.id = ++stuNum;//变化的
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

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

    public void setAge(int age) {
        this.age = age;
    }

    public int getId() {
        return id;
    }

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


//生成类对象时，直接赋值共享变量

public static void main(String[] args) {
        Demo01 one = new Demo01("谢特",17);
        Demo01 two = new Demo01("法克",18);
        Demo01.classNum = 101;//static关键字修饰，是共享的
        System.out.println(one.getName()+one.getAge()
                +Demo01.classNum+one.getId());
        System.out.println(two.getName()+two.getAge()
                +Demo01.classNum+two.getId());
    }

33.Arrays（数组工具类的用法）toString 和 sort

int[] array1 = {10,20,30};
        //将数组变成字符串
        String intStr = Arrays.toString(array1);
        System.out.println(intStr);//[10, 20, 30]
        int[] array2 = {3,4,5,2};
        //默认升序排列，无返回值
        Arrays.sort(array2);
        System.out.println(Arrays.toString(array2));//[2, 3, 4, 5]
        String[] array3 = {"aac","acc","abc"};
        Arrays.sort(array3);
        System.out.println(Arrays.toString(array3));//[aac, abc, acc]

34.java当中的数学方法 abs ceil floor round

System.out.println(Math.abs(-3.14));//绝对值
System.out.println(Math.ceil(10.1));//向上取整
System.out.println(Math.floor(9.9));//向下取整
System.out.println(Math.round(9.9));//四舍五入
System.out.println(Math.round(10.1));//四舍五入

35.继承：共性抽取，代码复用子类可继承父类的“内容”，同时子类还可以拥有自己的内容

再继承关系中，子类可以被当作父类看待无论是方法还是变量，如果没有都向上找

36.方法中的变量，本类的成员变量（this)，父类的成员变量(super)

int num = 20;
public void method(){
    int num = 30;
    System.out.println(num);//30
    System.out.println(this.num);//20
    System.out.println(super.num);//10   父类的
    }

37，覆盖重写(override)：在继承关系中，方法名一样，参数列表也一样（必须确保父子类中方法名和参数列表都一样），

而重载(overload)是方法名一样，但参数列表不一样

38.子类方法的返回值的范围必须小于等于父类方法的返回值子类方法的权限必须大于等于父类方法的权限修饰符 //public > protected > (default) > private

39.对于覆盖重写父类的方法。super.方法名（），父类的重复利用，其他的自己添加新的

@Override
        public void show() {
        super.show();//把父类的show方法拿过来重复利用
        //自己子类再来添加更多内容
        System.out.println("show name");
        System.out.println("show imagine");

40子类必须调用父类的构造方法.

子类构造方法中有一个默认隐含的super（）（调用父类无参构造方法），先调用父类的构造方法，再调用子类的构造方法

调用父类有参构造方法 super(参数) 就是重载一下父类无参、有参构造方法只能调用一个，且只能再子类的构造方法中第一个语句才能调用

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。