1.面向对象的思想
面向对象是基于面向过程的编程思想.
面向过程:强调的是每一个功能的步骤
面向对象:强调的是对象,然后由对象去调用功能
特点
是一种更符合我们思考习惯的思想
可以将复杂的事情简单化
将我们从执行者变成了指挥者
角色发生了转换
定义一个学生类
1 public class Student {
2 //成员变量
3 //姓名
4 String name;
5 //年龄
6 int age;
7
8 //成员方法
9 //学习的方法
10 public void study() {
11 System.out.println("学习");
12 }
13
14 //吃饭的方法
15 public void eat() {
16 System.out.println("吃饭");
17 }
18 }
定义一个手机类
1 public class Phone {
2 //品牌
3 String brand;
4 //价格
5 int price;
6 //颜色
7 String color;
8
9 //打电话
10 public void call(String name) {
11 System.out.println("给"+name+"打电话");
12 }
13
14 //发短信
15 public void sendMessage() {
16 System.out.println("群发短信");
17 }
18 }
2.成员变量和局部变量的区别
在类中的位置不同
成员变量：类中，方法外
局部变量：方法中或者方法声明上(形式参数)
在内存中的位置不同
成员变量：堆内存
局部变量：栈内存
生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
初始化值的不同
成员变量：有默认值
局部变量：没有默认值。必须先定义，赋值，最后使用
1 public class DemoVariable {
2 int x; //成员变量
3
4 public void show() {
5 int y = 0; //局部变量
6
7 System.out.println(x);
8 System.out.println(y);
9 }
10 }
3.封装
private关键字由来及其使用
private关键字：
是一个权限修饰符。
可以修饰成员(成员变量和成员方法)
被private修饰的成员只在本类中才能访问。
1 public class Student {
2 String name;
3 //int age;
4 private int age;
5
6 public void setAge(int a) {
7 if(a<0 || a>200) {
8 System.out.println("你给的年龄有误");
9 }else {
10 age = a;
11 }
12 }
13
14 public int getAge() {
15 return age;
16 }
17
18 public void show() {
19 System.out.println("姓名是："+name+",年龄是："+age);
20 }
21 }
private最常见的应用：
把成员变量用private修饰
提供对应的getXxx()/setXxx()方法
一个标准的案例的使用
1 public class Student {
2 private String name;
3 private int age;
4
5 public void setName(String n) {
6 name = n;
7 }
8
9 public String getName() {
10 return name;
11 }
12
13 public void setAge(inta) {
14 age = a;
15 }
16
17 public int getAge() {
18 return age;
19 }
20 }
封装的概述和好处
封装概述
是面向对象三大特征之一
是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。就像刚才说的年龄。
封装原则：
将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。
成员变量private，提供对应的getXxx()/setXxx()方法
好处：
通过方法来控制成员变量的操作，提高了代码的安全性
把代码用方法进行封装，提高了代码的复用性
4.this关键字
this:代表所在类的对象引用
方法被哪个对象调用，this就代表那个对象
this关键字的使用
局部变量隐藏成员变量(局部变量和成员变量重名)
1 public class Student {
2 private String name;
3 private int age;
4
5 public void setName(String name) {
6 //name = name;
7 = name;
8 }
9
10 public String getName() {
11 return name;
12 }
13
14 public void setAge(intage) {
15 //age = age;
16 this.age = age;
17 }
18
19 public int getAge() {
20 return age;
21 }
22 }
5.构造方法
作用
给对象的数据进行初始化
格式
方法名与类名相同
没有返回值类型，连void都没有
没有具体的返回值
修饰符 构造方法名(参数列表){
}
注意事项
如果你不提供构造方法，系统会给出默认构造方法
如果你提供了构造方法，系统将不再提供
构造方法也是可以重载的（即使用时带参构造和无参构造可同时使用）
1 public class Student {
2 private String name;
3 private int age;
4
5 /*
6 public Student() {
7 System.out.println("构造方法");
8 }
9 */
10
11 public Student() {}
12
13 public Student(String name) {
14 = name;
15 }
16
17 public Student(int age) {
18 this.age = age;
19 }
20
21 public Student(String name,int age) {
22 = name;
23 this.age = age;
24 }
25
26 public void show() {
27 System.out.println(name+"---"+age);
28 }
29 }
6.String类
字符串是由多个字符组成的一串数据
构造方法
public String(String original) 把字符串数据封装成字符串对象
public String(char[] value) 把字符数组的数据封装成字符串对象
public String(char[] value,int offset,int count) 把字符数组中的一部分数据封装成字符串对象
直接赋值也可以是一个对象(定义一个字符串变量)
通过构造方法创建字符串对象
String s = new String(“hello”);
直接赋值创建字符串对象
String s = “hello”;
判断功能方法
boolean equals(Object obj): 比较字符串的内容是否相同
boolean equalsIgnoreCase(String str): 比较字符串的内容是否相同,忽略大小写
boolean startsWith(String str): 判断字符串对象是否以指定的str开头
boolean endsWith(String str): 判断字符串对象是否以指定的str结尾
获取功能方法
int length():获取字符串的长度，其实也就是字符个数
char charAt(int index):获取指定索引处的字符
int indexOf(String str):获取str在字符串对象中第一次出现的索引,没有返回-1
String substring(int start):从start开始截取字符串到字符串结尾
String substring(int start,int end):从start开始，到end结束截取字符串;包括start，不包括end
转换功能方法
char[] toCharArray():把字符串转换为字符数组
String toLowerCase():把字符串转换为小写字符串
String toUpperCase():把字符串转换为大写字符串
去除空格和分割功能方法
String trim()去除字符串两端空格
String[] split(String str)按照指定符号分割字符串
7.类名作为形式参数和返回值
类名作为形式参数案例:需要的其实是该类的对象
1 class Test {
2 public void show(Person p){
3 p.eat();
4 }
5 }
类名作为返回值案例:返回的其实是该类的对象
1 class Test {
2 public Person show(){
3 Person p = new Person("小王");
4 return p;
5 }
6 }
8.StringBuilder类
String与StringBuilder的区别：
String的内容是固定的。
StringBuilder的内容是可变的。
添加功能
public StringBuilder append(任意类型):添加数据，并返回自身对象
反转功能
public StringBuilder reverse()
1 public class DemoStringBuilder {
2 public static void main(String[] args) {
3 //创建对象
4 StringBuilder builder = new StringBuilder();
5 //链式编程
6 builder.append("hello").append("world").append(true).append(100);
7
8 System.out.println("builder:"+builder);
9
10 //public StringBuilder reverse()
11 builder.reverse();
12 System.out.println("builder:"+builder);
13 }
14 }
9.ArrayList集合
ArrayList<E>集合:大小可变数组的实现
<E>:是一种特殊的数据类型，泛型。
在出现E的地方我们使用引用数据类型替换即可
举例：ArrayList<String>,ArrayList<Student>
构造方法
ArrayList()
成员方法
添加元素
public boolean add(E e):添加元素
public void add(int index,E element):在指定的索引处添加一个元素
1 public class DemoArrayList {
2 public static void main(String[] args) {
3 //创建集合对象
4 ArrayList<String> list = new ArrayList<String>();
5
6 //add(E e):添加元素
7 list.add("hello");
8 list.add("world");
9 list.add("java");
10
11 //add(int index,E element):在指定的索引处添加一个元素
12 list.add(1, "android");
13
14 System.out.println("array:"+list);
15 }
16 }
获取元素
public E get(int index):返回指定索引处的元素
集合长度
public int size():返回集合中的元素的个数
删除元素
public boolean remove(Object o):删除指定的元素，返回删除是否成功
public E remove(int index):删除指定索引处的元素，返回被删除的元素
修改元素
public E set(int index,E element):修改指定索引处的元素，返回被修改的元素
10.FileWriter和FileReader
FileWirter写数据
构造方法
FileWriter(String fileName) 传递一个文件名称
成员方法
void write(String str) 往文件中写入一个字符串。
void flush() 刷新该流的缓冲，把内存缓冲区中的数据刷新到文件中。
void close() 关闭此流，但要先刷新它。
输出流写数据的步骤：
1.创建输出流对象
2.调用输出流对象的写数据的方法
3.释放资源
路径:
相对路径：相对当前项目而言的，在项目的根目录下(a.txt)
绝对路径：以盘符开始的路径(d:\\a.txt)
close()和flush()方法的区别：
flush():刷新缓冲区。流对象还可以继续使用。
close():先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。
FileWriter写数据的5个方法
void write(String str):写一个字符串数据
void write(String str,int index,int len):写一个字符串中的一部分数据, index:开始索引,len:写几个
void write(int ch):写一个字符数据,这里写int类型的好处是既可以写char类型的数据，也可以写char对应的int类型的值。'a',97
void write(char[] chs):写一个字符数组数据
void write(char[] chs,int index,int len):写一个字符数组的一部分数据, index:开始索引,len:写几个
换行问题
windows:\r\n
linux:\n
mac:\r
换行符可以写在第一个数据的结尾,也可以写在第二个数据的开头
FileReader读数据
构造方法
FileReader(String fileName) 传递要读取的文件名称
成员方法
int read() 读取单个字符并返回
int read(char[] cbuf) 一次读取一个字符数组的数据，返回的是实际读取的字符个数
输入流读文件的步骤：
1.创建输入流对象
2.调用输入流对象的读数据方法
3.释放资源
一次读写一个字符数组复制文本文件
1 public class Demo02CopyFile {
2 public static void main(String[] args) throws IOException {
3 //创建输入流对象
4 FileReader fr = new FileReader("Demo01FileWriter.java");
5 //创建输出流对象
6 FileWriter fw = new FileWriter("Copy.java");
7
8 //读写数据
9 char[] chs = new char[1024];
10 int len;
11 while((len=fr.read(chs))!=-1) {
12 fw.write(chs, 0, len);
13 }
14
15 //释放资源
16 fw.close();
17 fr.close();
18 }
19 }
11.BufferedWriter和BufferedReader
BufferedWriter:将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
BufferedReader:从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
1 public class Demo01BufferedStream {
2 public static void main(String[] args) throws IOException {
3 //创建输出缓冲流对象
4 BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
5 bw.write("hello");
6 //bw.flush();
7 bw.close();
8
9 //创建输入缓冲流对象
10 BufferedReader br = new BufferedReader(new FileReader("bw.txt "));
11
12 /*
13 //一次读写一个字符
14 int ch;
15 while((ch=br.read())!=-1){
16 System.out.print((char)ch);
17 }
18 */
19
20 //一次读写一个字符数组
21 char[] chs = new char[1024];
22 int len;
23 while((len=br.read(chs))!=-1) {
24 System.out.print(new String(chs,0,len));
25 }
26
27 //释放资源
28 br.close();
29 }
30 }
缓冲流的特殊功能
BufferedWriter
void newLine():写一个换行符，这个换行符由系统决定
BufferedReader
String readLine():一次读取一行数据，但是不读取换行符
从文本文件中读取数据到ArrayList集合中，并遍历集合
例：每一行数据作为一个字符串元素
1 public class Demo03FileToArrayListTest {
2 public static void main(String[] args) throws IOException {
3 //创建输入缓冲流对象
4 BufferedReader br =
5 new BufferedReader(new FileReader("array.txt"));
6
7 //创建集合对象
8 ArrayList<String> list = new ArrayList<String>();
9
10 //读取数据，每次读取一行数据，把该行数据作为一个元素存储到集合中
11 String line;
12 while((line=br.readLine())!=null) {
13 list.add(line);
14 }
15
16 //释放资源
17 br.close();
18
19 //遍历集合
20 for(int i=0; i<list.size(); i++) {
21 String s = list.get(i);
22 System.out.println(s);
23 }
24 }
25 }
