黑马程序员JAVA学习第二节

黑马程序员JAVA学习第二节2021.5.22

（视频链接黑马程序员全套Java教程_Java基础入门教程，零基础小白自学Java必备教程_哔哩哔哩 (゜-゜)つロ 干杯~-bilibili）

本节主要内容是 数组、方法、类与对象、字符串的学习，对应视频58-133

数组：

1.数组的动态初始化：

int [] arr = new int[3];
int: 数组的数据类型 []: 代表这是一个数组 arr: 代表数组的名称
等号右边：
new: 为数组开辟内存空间 int: 数组的数据类型 []: 代表这是一个数组

2.内存分配：栈内存，存储局部变量，如main方法定义的变量；堆内存，存储new出来的内容（实体，对象）

3.多个数组指向相同内存 int[] arr2=arr  修改任何一个都会发生改变

4.数组静态初始化：初始化时指定每个数组元素值

int[] arr = new int[]{1,2,3}://简化前
int[] arr = {1, 2, 3};//简化后

5.对数组遍历（两种方法）：

for(int x=0; x<arr.length; x++) 
for(int num : arr)
 {
System.out.print(num + " ");
}

 

方法：

1.方法调用：

public static void method (  ) {//定义
// 方法体;
}
method ();//调用

2.方法重载：

多个方法在同一个类中
多个方法具有相同的方法名
多个方法的参数不相同，类型不同或者数量不同

public class MethodDemo {
public static void fn(int a) {
 //方法体
 }
  public static int fn(double a) {
 //方法体
 }
}

3.方法参数传递：

基本数据类型的参数，形式参数的改变，不影响实际参数。（int）

对于引用类型的参数，形式参数的改变，影响实际参数的值。(数组，主要是变量和地址的区别)

4.输出的区别：

System.out.println(“内容”);// 输出内容并换行
System.out.print(“内容”); //输出内容不换行
System.out.println(); //起到换行的作用

面向对象基础

类与对象

1.类与对象的关系
类：类是对现实生活中一类具有共同属性和行为的事物的抽象
对象：是能够看得到摸的着的真实存在的实体
简单理解： 类是对事物的一种描述，对象则为具体存在的事物

2.类的创建

public class Phone {
  //成员变量
  String brand;
  int price;
  //成员方法
  public void call() {
    System.out.println("打电话");
 }
  public void sendMessage() {
    System.out.println("发短信");
 }
}

3.对象的创建

public class PhoneDemo {
  public static void main(String[] args) {
    Phone p = new Phone();
    //使用成员变量
    System.out.println(p.brand);
    System.out.println(p.price);
    p.brand = "小米";
    p.price = 2999;
    System.out.println(p.brand);
    System.out.println(p.price);
    //使用成员方法
    p.call();
    p.sendMessage();
 }
}

4.成员变量与局部变量

5.private关键字

private是一个修饰符，可以用来修饰成员（成员变量，成员方法）
被 private修饰的成员，只能在本类进行访问，针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作。
1）提供 “get变量名()”方法，用于获取成员变量的值，方法用public修饰
2）提供 “set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰

class Student {
  //成员变量
  String name;
  private int age;
  //提供get/set方法
  public void setAge(int a) {
    if(a<0 || a>120) {
      System.out.println("你给的年龄有误");
   } else {
      age = a;
   }
 }
  public int getAge() {
    return age;
 }
  //成员方法
public void show() {
    System.out.println(name + "," + age);
 }
}

6.this 关键字

this 修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）
1）方法的形参如果与成员变量同名，不带 this修饰的变量指的是形参，而不是成员变量
2）方法的形参没有与成员变量同名，不带 this修饰的变量指的是成员变量 

3）this 代表当前调用方法的引用，哪个对象调用的方法，this就代表哪一个对象

public class Student {
  private String name;
  public void setName(String name) {
    this.name = name;
 }
  public String getName() {
    return name;
 } 
}

7.封装

1）封装是面向对象三大特征之一（封装、继承、多态）

2）封装原则 将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏
信息的操作和访问成员变量private，提供对应的getXxx()/setXxx()方法
3） 封装好处：通过方法来控制成员变量的操作，提高了代码的安全性 把代码用方法进行封装，提高了代码的复用性

8.构造方法：

特殊的方法，主要是为了创建对象

class Student {
  //构造方法
  public Student() {
    System.out.println("无参构造方法");
 }
}

1）构造方法的创建
如果没有定义构造方法，系统将给出一个默认的无参数构造方法 如果定义了构造方法，系统将不再提供默认的构造
方法
2）构造方法的重载
如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法
3）推荐的使用方式
无论是否使用，都手工书写无参数构造方法
4）重要功能！
可以使用带参构造，为成员变量进行初始化

5）快捷键：alt+insert，shift全选

class Student {
  private String name;
  private int age;
  public Student() {}
  public Student(String name，int age) {
    this.name = name;
    this.age = age;
 }
}

字符串

1.String类特点

1）字符串不可变，它们的值在创建后不能被更改
2）虽然 String 的值是不可变的，但是它们可以被共享
3）字符串效果上相当于字符数组 ( char[] )，但是底层原理是字节数组( byte[] )

2.String 构造方法

   //public String()：创建一个空白字符串对象，不含有任何内容
    String s1 = new String();
    System.out.println("s1:" + s1);
    //public String(char[] chs)：根据字符数组的内容，来创建字符串对象 输出：abc
    char[] chs = {'a', 'b', 'c'};
    String s2 = new String(chs);
    System.out.println("s2:" + s2);
    //public String(byte[] bys)：根据字节数组的内容，来创建字符串对象 输出：abc（ascall码）
    byte[] bys = {97, 98, 99};
    String s3 = new String(bys);
    System.out.println("s3:" + s3);
    //String s = “abc”; 直接赋值的方式创建字符串对象，内容就是abc
    String s4 = "abc";
    System.out.println("s4:" + s4);

区别：

1）通过构造方法创建
通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然内容相同，但是地址值不同
2）直接赋值方式创建
以“”方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次，JVM 都只会建立一
个 String 对象，并在字符串池中维护

3.字符串的比较

字符串1==字符串2 比较的是地址。

System.out.println(s1.equals(s2)); //返回true 比较两个字符串内容是否相同、区分大小写

 //已知用户名和密码，定义两个字符串表示即可
    String username = "itheima";
    String password = "czbk";
    //用循环实现多次机会，这里的次数明确，采用for循环实现，并在登录成功的时候，使用break结束循环
    for(int i=0; i<3; i++) {
      //键盘录入要登录的用户名和密码，用 Scanner 实现
      Scanner sc = new Scanner(System.in);
      System.out.println("请输入用户名：");
      String name = sc.nextLine();
      System.out.println("请输入密码：");
      String pwd = sc.nextLine();
       if (name.equals(username) && pwd.equals(password)) {
        System.out.println("登录成功");
        break;
     } else {
        if(2-i == 0) {
          System.out.println("你的账户被锁定，请与管理员联系");
       } else {
          //2,1,0
          //i,0,1,2
          System.out.println("登录失败，你还有" + (2 - i) + "次机会");
       }
     }
   }
 }

4.键盘输入字符串：String name = sc.nextLine();

5.遍历字符串：line.charAt(i)

    Scanner sc = new Scanner(System.in);
    System.out.println("请输入一个字符串：");
    String line = sc.nextLine();
    for(int i=0; i<line.length(); i++) 
      System.out.println(line.charAt(i));

6.快捷键：sc.nextline()  ctrl+alt+V 生成左边内容

7.统计字符次数：

    for(int i=0; i<line.length(); i++) {
      char ch = line.charAt(i);//判断该字符属于哪种类型，然后对应类型的统计变量+1
      if(ch>='A' && ch<='Z') 
        bigCount++;
   }

8.字符串拼接：s+src

9.StringBuilder：与String相比 其内容可变

构造方法：

    StringBuilder sb = new StringBuilder();//创建一个空白可变字符串对象，不含有任何内容
    System.out.println("sb:" + sb);
    System.out.println("sb.length():" + sb.length());
    //public StringBuilder(String str)：根据字符串的内容，来创建可变字符串对象
    StringBuilder sb2 = new StringBuilder("hello");
    System.out.println("sb2:" + sb2);
    System.out.println("sb2.length():" + sb2.length());

添加和反转方法：

StringBuilder sb = new StringBuilder();
sb.append("hello").append("world").append("java").append(100);//链式编程
sb.reverse();

StringBuilder和String互换：

StringBuilder sb = new StringBuilder();
String s = sb.toString(); //SB to S

String s = "hello";
StringBuilder sb = new StringBuilder(s);//S to SB