文章目录
11 面向对象基础11.1 类和对象11.2 类的定义11.3 对象的使用11.4 成员变量和局部变量11.5 封装1. private关键字2. this关键字 11.6 构造器11.7 标准类的制作 12 String12.1 ==、equals()12.2 String常见方法12.3 StringBuilder12.8 StringBuilder和String的相互转换 13 ArrayList13.1 ArrayList构造器和添加方法13.2 ArrayList常用方法本博客配套黑马教学视频，视频请查看B站，本博客从第99个视频开始，第99集视频链接
前面的视频配套博客如下：
黑马全套Java教程（一）
黑马全套Java教程（二）
11 面向对象基础
11.1 类和对象
什么是对象？：客观存在的事物，都可称为对象！万物皆对象
什么是类？：类是对现实生活中一类具有共同属性和行为的事物的抽象
类的特点：
类是对象的数据类型类是具有相同属性和行为的一组对象的集合
什么是对象的属性？：属性：对象具有的各种特征，每个对象的每个属性都拥有特定的值
什么是对象的行为？：行为：对象能够执行的操作
类和对象的关系
类：类是对现实生活中一类具有共同属性和行为的事物的抽象
对象：是能够看得到摸得着的真实存在的实体
11.2 类的定义
类是对现实生活中一类具有共同属性和行为的事物的抽象
类的组成：属性和行为
属性：在类中通过成员变量来体现（类中方法外的变量）行为：在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）
类的定义步骤如下：
例：Phone.java
public class Phone {//成员变量String brand;int price;//成员方法public void call(){System.out.println("打电话");}public void sendMessage(){System.out.println("发短信");}}
11.3 对象的使用
例：PhoneDemo.java
public class PhoneDemo {public static void main(String[] args) {//创建对象Phone p = new Phone();//使用成员变量System.out.println(p.brand); //null 有默认值System.out.println(p.price); //0System.out.println("-----------------");p.brand = "小米";p.price = 2999;System.out.println(p.brand);System.out.println(p.price);System.out.println("-----------------");//成员方法的使用p.call();p.sendMessage();}}
案例：定义学生类，然后定义学生测试类，在测试类中完成对成员变量和成员方法的使用
Student.java
package myClass;/*学生类*/public class Student {//成员变量String name;int age;//成员方法public void study(){System.out.println("好好学习，天天向上！");}public void doHomework(){System.out.println("键盘敲烂，月薪过万！");}}
StudentDemo.java
package myClass;/*学生测试类*/public class StudentDemo {public static void main(String[] args) {//创建对象Student s = new Student();System.out.println("s:" + s);//使用对象System.out.println(s.name + "," + s.age);s.name = "林青霞";s.age = 30;System.out.println(s.name + "," + s.age);s.study();s.doHomework();}}
例：创建多个对象，指向不同
package myClass;public class StudentTest02 {public static void main(String[] args) {//创建第一个对象并使用Student s1 = new Student();s1.name = "林青霞";s1.age = 30;System.out.println("s1" + s1);System.out.println(s1.name + "," + s1.age);s1.study();s1.doHomework();System.out.println("-----------------");//创建第二个对象Student s2 = new Student();s2.name="张曼玉";s2.age=28;System.out.println("s2" + s2);System.out.println(s2.name + "," + s2.age);s2.study();s2.doHomework();}}
例：创建多个对象，指向相同
package myClass;/*多个对象指向相同*/public class StduentTest03 {public static void main(String[] args) {//创建爱你第一个对象并使用Student s1 = new Student();s1.name = "林青霞";s1.age = 30;System.out.println("s1" + s1);System.out.println(s1.name + "," + s1.age);System.out.println("--------------");//把第一个对象的地址赋值给第二个对象Student s2 = s1;s2.name = "张曼玉";s2.age = 28;System.out.println("s2" + s2);System.out.println(s2.name + "," + s2.age);}}
注意，这里修改s2会改变s1
11.4 成员变量和局部变量
什么是成员变量和局部变量
区别如下：
11.5 封装
为什么要封装?
有些机密的东西不能直接展示出来，可以进行封装
1. private关键字
private关键字
是一个权限修饰符可以修饰成员（成员变量和成员方法）作用是保护成员不被别的类使用，被private修饰的成员只在本类中才能访问
针对private修饰的成员变量，如果需要被其他类使用，提供响应的操作
提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰
例：这里用private封装年龄
Student.java
package myClass2;/*学生类*/public class Student {//成员变量String name;//int age;private int age;//提供get/set方法public void setAge(int a){age = 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);}}
StudentDemo.java
package myClass2;/*学生测试类*/public class StudentDemo {public static void main(String[] args) {//创建对象Student s = new Student();//给成员变量赋值s.name = "林青霞";//s.age = 30;//s.setAge(30);s.setAge(-30);//调用方法s.show();}}
2. this关键字
上面是用a表示age，为了命名规范，这里用this.age比a好得多
代码实现：
Student.java
package myClass03;/*学生类*/public class Student {//成员变量private String name;private int age;//get/set方法public void setName(String name){//name = name;this.name = name; //相当于Python的self}public String getName(){return name;}public void setAge(int age){this.age = age;}public int getAge(){return age;}public void show(){System.out.println(name + "," + age);}}
StudentDemo.java
package myClass03;import org.w3c.dom.ls.LSOutput;/*学生测试类*/public class StudentDemo {public static void main(String[] args) {//创建对象Student s = new Student();//使用set方法给成员变量赋值s.setName("林青霞");s.setAge(30);s.show();//使用get方法获取成员变量的值//System.out.println(s.getName() + "---" + s.getAge());}}
封装总结：
1.封装概述
是面向对象三大特征之一（封装，继承，多态）
是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的
2.封装原则
将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法实现对隐藏信息的操作和访问成员变量private，提供对应的setXxx()和getXxx()方法。
3.封装的好处
通过方法来控制成员变量的操作，提高了代码的安全性
把代码用方法进行封装，提高了代码的复用性
11.6 构造器
功能：主要是完成对象数据的初始化
注意事项
如果没有定义构造方法，系统将给出一个默认的无参数构造方法如果定义了构造方法，系统将不再提供默认的构造方法
构造方法的重载
如果自定义了带参数构造方法，还使用无参数构造方法，就必须再写一个无参数构造方法
推荐方式
无论是否使用，都手工写一个无参数构造方法
代码实现如下：
Student.java
public class Student {private String name;private int age;//构造方法的重载：构造方法可以给定参数赋值public Student(){} //无参构造方法public Student(String name){this.name = name;}public Student(int age){this.age = age;}public Student(String name, int age){this.name = name;this.age = age;}public void show(){System.out.println(name + "," + age);}}
StudentDemo.java
package myClass04;/*测试类*/public class StudentDemo {public static void main(String[] args) {//创建对象Student s = new Student();s.show();System.out.println("-----------------");//public Student(String name)Student s2 = new Student("林青霞");s2.show();System.out.println("-----------------");//public Student(int age)Student s3 = new Student(30);s3.show();System.out.println("------------------");//public Student(String name, int age)Student s4 = new Student("林青霞", 30);s4.show();}}
11.7 标准类的制作
例：Student.java
package myClass05;/*成员变量使用private修饰构造方法提供一个无参构造方法提供一个带多个参数的构造方法成员方法提供每一个成员变量对应的setXxx()/getXxx()提供一个显示对象信息的show()*/public class Student {//成员变量private String name;private int age;//构造方法public Student(){}public Student(String name, int age){this.name = name;this.age = age;}//成员方法public void setName(String name){this.name = name;}public String getName(){return name;}public void setAge(int age){this.age= age;}public int getAge(){return age;}public void show(){System.out.println(name + "," + age);}}
StudentDemo.java
package myClass05;/*创建对象并为其成员变量赋值的两种方法1.无参数构造方法创建对象后使用set赋值2.使用带参数构造方法直接创建带有属性值的对象*/public class StudentDemo {public static void main(String[] args) {//1.无参构造方法创建对象Student s1 = new Student();s1.setName("林青霞");s1.setAge(30);s1.show();//2.使用带参数的构造方法赋值Student s2 = new Student("林青霞", 30);s2.show();}}
12 String
String类在java.lang包下，所以使用的时候不需要导包
String类代表字符串，Java程序中的所有字符串文字（例如“abc”）都被实现为此类的实例；也就是说，Java程序中所有的双引号字符串，都是String类的对象
字符串的特点
字符串不可变，它们的值在创建后不能被更改虽然String的值是不可变的，但是它们可以被共享字符串效果上相当于字符数组（char[]），但是底层原理是字节数组（byte[]）
String构造方法
public class StringDemo01 {public static void main(String[] args) {//1. public String()：创建一个空白字符串对象String s1 = new String();System.out.println("s1:" + s1); //输出空白内容//2. public String(char[] chs)：根据字符数组的内容，来创建字符串对象char[] chs = {'a', 'b', 'c'};String s2 = new String(chs);System.out.println("s2:" + s2);//3. public String(byte[] bys)：根据字节数组的内容，来创建字符串对象byte[] bys = {97,98,99};String s3 = new String(bys);System.out.println("s3:" + s3);//4. String s = "abc" 直接赋值的方法创建字符串对象，内容就是abcString s4 = "abc"; // 这里是没有使用构造方法的System.out.println("s4:" + s4);}}
String对象的特点
特点1
特点2
特点1内存过程：输出false
package myString;public class StringDemo1 {public static void main(String[] args) {//构造方法的方式得到对象char[] chs = {'a', 'b', 'c'};String s1 = new String(chs);String s2 = new String(chs);System.out.println(s1==s2);}}
特点2内存过程：输出true
代码实现比较如下：
package myString;public class StringDemo2 {public static void main(String[] args) {//直接赋值的方式得到对象String s3 = "abc";String s4 = "abc";System.out.println(s3==s4);}}
12.1 ==、equals()
使用==做比较
基本类型：比较的是数据值是否相同引用类型：比较的是地址值是否相同
字符串是对象，它比较内容是否相同，是通过一个方法来实现的，这个方法叫：equals()，返回值为bool类型。
public boolean equals(Object anObject)
public class StringDemo02 {public static void main(String[] args) {//构造方法的方式得到对象char[] chs = {'a','b','c'};String s1 = new String(chs);String s2 = new String(chs);//直接赋值的方式得到对象String s3 = "abc";String s4 = "abc";//比较字符串对象地址是否相同System.out.println(s1==s2); //falseSystem.out.println(s2==s3); //falseSystem.out.println(s3==s4); //trueSystem.out.println("--------------");//比较字符串内容是否相同System.out.println(s1.equals(s2)); //trueSystem.out.println(s1.equals(s3)); //trueSystem.out.println(s3.equals(s4)); //true}}
案例1：用户登录模拟
package myString;import java.util.Scanner;public class StringTest01 {public static void main(String[] args) {//已知用户名和密码，定义两个字符串表示即可String username = "itheima";String password = "czbk";//for循环实现多次机会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 {System.out.println("登录失败，你还有" + (2 - i) + "次机会");}}}}}
案例2：遍历字符串
package myString;import java.util.Scanner;public class StringTest02 {public static void main(String[] args) {//键盘录入一个字符串，用Scanner实现Scanner sc = new Scanner(System.in);System.out.println("请输入一个字符串：");String line = sc.nextLine();//遍历字符串，首先要能够获取到字符串的每一个字符//length()方法获取字符串长度for (int i = 0; i < line.length(); i++) {System.out.println(line.charAt(i));}}}
案例3：统计字符次数
package myString;import java.util.Scanner;public class StringTest03 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.println("请输入字符串：");String line = sc.nextLine();int DaXie = 0;int XiaoXie = 0;int ZiMu = 0;for (int i = 0; i < line.length(); i++) {char ch = line.charAt(i);if (ch >= 'A' && ch <= 'Z') {DaXie += 1;} else if (ch >= 'a' && ch <= 'z') {XiaoXie += 1;} else if (ch >= '0' && ch <= '9') {ZiMu += 1;}}System.out.println("大写字母个数：" + DaXie);System.out.println("小写字母个数：" + XiaoXie);System.out.println("数字个数：" + ZiMu);}}
案例4：拼接字符串
package myString;/*拼接字符串*/public class StringTest04 {public static void main(String[] args) {int[] arr = {1, 2, 3};//调用方法，接收结果String s = arrayToString(arr);System.out.println("s: "+ s);}public static String arrayToString(int[] arr) {//在方法中遍历数组，按照要求进行拼接String s = "";s += "[";for (int i = 0; i < arr.length; i++) {if (i == arr.length - 1) {s += arr[i];} else {s += arr[i];s += ", ";}}s += "]";return s;}}
案例5：字符串反转
package myString;import java.util.Scanner;/*字符串反转*/public class StringTest05 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.println("请输入一个字符串：");String s = sc.nextLine();String sReverse = StringToReverse(s);System.out.println("反转后：" + sReverse);}public static String StringToReverse(String s) {String ss = "";for (int i = s.length() - 1; i >= 0; i--) {ss += s.charAt(i);}return ss;}}
12.2 String常见方法
可在帮助文档中查看到：
字符串中的方法比较多！
12.3 StringBuilder
String内存过程：我们知道字符串是不可变的，常量
可以看到进行字符串拼接会浪费堆内存
所以引出来了StringBuilder
StringBuilder是一个可变的字符串类，我们可以把它看成是一个容器，这里的可变指的是StringBuilder对象中的内容是可变的
String和StringBuilder的区别？
String：内容是不可变的StringBuilder：内容是可变的
StringBuilder构造方法
例1
public class StringBuilderDemo01 {public static void main(String[] args) {//1.public StringBuilder()：创建一个空白可变字符串对象，不含有任何内容StringBuilder sb = new StringBuilder();System.out.println("sb:" + sb);System.out.println("sb.length():" + sb.length());System.out.println("--------------------------");//2.public StringBuilder(String str)：根据字符串的内容，来创建可变字符串对象StringBuilder sb2 = new StringBuilder("hello");System.out.println("sb2:" + sb2);System.out.println("sb2.length():" + sb2.length());}}
StringBuilder添加和反转的方法
例：添加：.append()
package myString;public class StringBuilderDemo02 {public static void main(String[] args) {//创建对象StringBuilder sb = new StringBuilder();//StringBuilder sb2 = new StringBuilder("hello");StringBuilder sb3 = sb.append("hello");System.out.println("sb:" + sb);System.out.println("sb2:" + sb2);System.out.println("-----------------");System.out.println("sb==sb2:" + (sb==sb2));System.out.println("sb==sb3:" + (sb==sb3));}}
例：反转：.reverse()
package myStringBuilder;/*StringBuilder 的添加和反转方法public StringBuilder append(任意类型)：添加数据，并返回对象本身public StringBuilder reverse()：返回相反的字符序列*/public class StringBuilderDemo01 {public static void main(String[] args) {//创建对象StringBuilder sb = new StringBuilder();// sb.append("hello");// sb.append("world");// sb.append("java");// sb.append(100);//链式编程sb.append("hello").append("world").append("java").append(100);System.out.println(sb);//反转sb.reverse();System.out.println(sb);}}
12.8 StringBuilder和String的相互转换
StringBuilder 转换为 String：toString()String 转换为 StringBuilder：public StringBuilder(String s)：通过构造方法就可以实现package myStringBuilder;/*StringBuilder 转换为 StringtoString()String 转换为 StringBuilderpublic StringBuilder(String s)：通过构造方法就可以实现*/public class StringBuilderDemo02 {public static void main(String[] args) {//1.StringBuilder to StringStringBuilder sb = new StringBuilder();sb.append("hello");//String s = sb; //这个是错误做法String s = sb.toString();System.out.println(s);//2.String to StringBuilderString ss = "hello";//StringBuilder s = ss; //这个是错误的StringBuilder sb2 = new StringBuilder(ss);System.out.println(sb2);}}
案例：拼接字符串
public class StringBuilderDemo03 {public static void main(String[] args) {int[] arr = {1, 2, 3};String s = pinJie(arr);System.out.println(s);}public static String pinJie(int[] arr) {StringBuilder sb = new StringBuilder();sb.append("[");for (int i = 0; i < arr.length; i++) {sb.append(arr[i]);if (i != arr.length - 1) {sb.append(",");}}sb.append("]");String s = sb.toString();return s;}}
案例：字符串反转
import java.util.Scanner;public class StringBuilderDemo04 {public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.println("请输入一个字符串：");String line = sc.nextLine();String s = stringReverse(line);System.out.println("反转后：" + s);}public static String stringReverse(String s){// StringBuilder sb = new StringBuilder(s);// sb.reverse();// String ss = sb.toString();// return ss;//用一行代码实现上面功能return new StringBuilder(s).reverse().toString();}}
这些方法都能在帮助文档中找到！
如下：
本博客到黑马视频的第133个！
13 ArrayList
集合类的特点：提供一种存储空间可变的存储模型，存储的数据容量可以发生改变
集合类有很多，目前只学习一个：ArrayLlist，需要导包
ArrayList< E>
可调整大小的数组实现< E>：是一种特殊的数据类型，泛型
什么用呢？
在出现E的地方我们使用引用数据类型替换即可
举例：ArrayList<String>，ArrayList<Student>
13.1 ArrayList构造器和添加方法
package myArrayList;import java.util.ArrayList;/*ArrayList构造方法：public ArrayList()：创建一个空的集合对象ArrayList添加方法：public bollean add(E e)：将指定的袁术追加到此集合的末尾public void add(int index, E,element)：在此集合中的指定未知插入指定的元素*/public class ArrayListDemo01 {public static void main(String[] args) {//public ArrayList()：创建一个空的集合对象//ArrayList<String> array = new ArrayList<>();ArrayList<String> array = new ArrayList<String>(); //这两个都行//add添加元素System.out.println(array.add("hello"));System.out.println(array.add("world"));array.add("100");//add指定位置添加元素array.add(1, "java"); //如果索引超出会报错array.add(4, "javaee");//输出集合System.out.println("array:" + array);}}
13.2 ArrayList常用方法
代码举例如下：
import java.util.ArrayList;public class ArrayListDemo02 {public static void main(String[] args) {//创建集合ArrayList<String> array = new ArrayList<String>();//添加元素array.add("world");array.add(1, "hello");array.add("java");array.add("python");System.out.println("array:" + array);//1.删除指定元素System.out.println("删除world：" + array.remove("world"));System.out.println("删除javaee：" + array.remove("javaee")); //没有这个,falseSystem.out.println("删除后array1:" + array + '\n');//2.删除指定索引的元素System.out.println("删除指定索引1，返回索引对应的值：" + array.remove(1)); //返回索引值的元素//System.out.println(array.remove(3)); //删除时索引越界会报错System.out.println("删除后array2:" + array + '\n');//3.修改索引对应的值System.out.println("修改索引1的值，返回被修改的值：" + array.set(1, "C++"));//注意：索引越界会报错System.out.println("修改后array3:" + array + '\n');//4.返回指定索引处的元素System.out.println("返回1索引的元素：" + array.get(1));//5.获取元素个数System.out.println("元素个数：" + array.size());}}
array:[world, hello, java, python]删除world：true删除javaee：false删除后array1:[hello, java, python]删除指定索引1，返回索引对应的值：java删除后array2:[hello, python]修改索引1的值，返回被修改的值：python修改后array3:[hello, C++]返回1索引的元素：C++元素个数：2
案例：存储字符串并遍历
package myArrayList;import java.util.ArrayList;public class ArrayListTest01 {public static void main(String[] args) {//创建集合对象ArrayList<String> array = new ArrayList<String>();//添加元素array.add("aaa");array.add("bbb");array.add("ccc");//遍历for (int i=0; i<array.size(); i++){String s = array.get(i);System.out.println(s);}}}
案例2：存储学生对象并遍历
package myArrayList;import java.util.ArrayList;public class ArrayTest02 {public static void main(String[] args) {//创建集合ArrayList<Student> array = new ArrayList<Student>(); //括号里面改了//创建学生对象Student s1 = new Student("林青霞", 30);Student s2 = new Student("风清扬", 33);Student s3 = new Student("张曼玉", 18);//添加学生对象到集合中array.add(s1);array.add(s2);array.add(s3);//遍历for (int i=0; i< array.size(); i++){Student s = array.get(i);System.out.println(s.getName() + "," + s.getAge());}}}
案例3：
package myArrayList;import java.util.ArrayList;import java.util.Scanner;public class ArrayTest03 {public static void main(String[] args) {//创建集合ArrayList<Student1> array = new ArrayList<Student1>();//键盘录入addStudent(array);addStudent(array);addStudent(array);//遍历集合for(int i=0; i<array.size(); i++){Student1 s = array.get(i);System.out.println(s.getName() + "," + s.getAge());}}public static void addStudent(ArrayList<Student1> array){//键盘录入Scanner sc = new Scanner(System.in);System.out.println("请输入学生姓名：");String name = sc.nextLine();System.out.println("请输入学生年龄：");String age = sc.nextLine();//创建学生对象Student1 s = new Student1();s.setName(name);s.setAge(age);//往集合中添加学生对象array.add(s);}}
此博客到视频139截止！
