Java学习周记week02

时间：2017-08-12 12:43:14 阅读：254 评论：0 收藏：0 [点我收藏+]

标签：复用方法 write name throw 索引 uil 格式 buffere

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 }

Java学习周记week02

标签：复用方法 write name throw 索引 uil 格式 buffere

原文地址：http://www.cnblogs.com/mistlight/p/7349744.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行