Java学习周记week02

Posted 2020-10-02

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         this.name = 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         this.name = name;
15     }
16     
17     public Student(int age) {
18         this.age = age;
19     }
20     
21     public Student(String name,int age) {
22         this.name = 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 }