Java面向对象

java 学习：

面向对象：

• 面向对象的基本概念：
• java是面向对象的程序语言，c是面向过程的程序语言，各有特长。

- 面向对象的三个主要特征：

• 封装性：
  对外部不可见，可以保护程序中的某些内容。
• 继承性：扩展功能。
• 多态：方法的重载，对象的多态性。

- 类与对象的关系：

• 面向对象的核心组成部分，就是类与对象。
• 类是对某一事物的描述，是抽象的，概念上的定义；

• 对象是实际存在的该类事物的每个个体，因而也称为实例（instance）。

-

- 类的定义：

class定义一个类，

    class类名称{
            数据类型 属性；
            ............    
    public 返回的数据类型 方法名称（参数1，参数2......）{
                程序语句；
                return 表达式；
            }
        }

类的名称首字母必须大写！

class Person{
//人中有姓名和年龄两个属性
    Srting name;   //姓名
    int age;        //年龄
    public void tell(){
        System.out.pringln("姓名："+name+"年龄："+age);
        }
    }

person类图：

第一层表示类的名称，类的名称与之前一样要求开头首字母大写；

第二层表示属性的定义，按照“访问权限 属性名称：属性类型”的格式定义；

第三层表示类中方法的定义，按照“访问权限 方法名称（）：方法返回值”的格式定义

- 对象的声明及使用：

• Person per = new Person();
• 声明对象：Person per,栈内存中声明的，与数组一样，数组名称就保存在栈内存之中， 只开辟了栈内存的对象是无法使用的，必须有其堆内存的引用才可以使用。

• 实例化对象：
  new Person(),在堆中开辟空间，所有的内容都是默认值。

  类属于引用数据类型，从数组中可以知道，引用数据类型必然存在栈内存-堆内存的引用关系，实际上，在类与对象的使用关系上必然存在这种关系。

• 使用格式：

    调用属性：对象.属性
  
    调用方法：对象.方法()
  

  有两种写法：

  Person per = new Person（）；
  per.name = "小明";
  

  或

  Person per = null;
  
  per = new Person();
  
  per.name = "小明"；
  

注意：

1. 对象是保存在栈内存之中，属性是保存在堆内存之中；

2. 在程序中所有的方法是保存在全局代码区之中的，此区中的内容是所有对象共享的；

3. 在使用对象的时候，对象必须被实例化之后才可以使用；

4. 实例化对象并不止指的是直接通过new关键字实现的，只要其有堆内存的空间指向，则就表示实例化成功。

5. 如果不实例化—则会出现空指向异常，在引用操作中，如果一个对象没有堆内存的引用，而是调用了类中的属性或方法，就会出现此问题；

6. 所谓的引用数据类型，实际上传递的是堆内存的使用权，可以同时为一个堆内存空间定义多个栈内存的引用操作。

总结

1. 掌握栈与堆内存的关系；
2. 对象保存在栈内存之中，而具体的内容保存在堆内存之中
3. 对象间的引用传递，实际上传递的就是堆内存空间的使用权
4. 垃圾的产生；

- 面向对象的封装性

封装就是保护内容：保证某些属性或方法不被外部看见。

- 封装的实现：

• 为属性封装：private 属性类型 属性名称
• 为方法封装：private 方法返回值 方法名称（参数列表）{}

- 访问封装的内容：

被封装的属性如果需要被访问，则需要编写setter和getter方法完成；

eg:

    private String name;
        public void SetterName(String n){  //设置姓名
            name = "skye"
        }
        public void GetterName(){
            return name;
        }

注意：

1. 如果年龄设置有问题，则不应该为属性赋值；
2. 应在setter方法中加入检验；在getter方法中只是把内容简单的取回；
3. 封装性在java中有很多种形式，private只是最基本的一种形式，也是一种比较常见的形式；
4. 类中的每一个属性都必须封装；

- 构造方法与匿名对象

• 构造方法的概念及调用时机

什么是构造方法？
只要一有对象产生实例化，就会调用构造方法。
构造方法的定义格式：

class 类名称{
    访问权限 类名称（类型1 参数1，类型2 参数2，......）{
        程序语句；
        ....//构造方法没有返回值
    }
}

构造方法的申明：

1. 构造方法的名称必须与类名称一致；
2. 构造方法的申明处不能有任何返回值类型的申明；
3. 不能在构造方法中使用return返回一个值；

4. 申明对象时，并不去调用构造方法；

   每个类中都会有一个构造方法；
   java的操作机制中，如果一个类没有明确的声明一个构造方法，则会自动生成一个无参的什么都不做的构造方法，供用户使用。

构造方法的主要目的是为类中的属性进行初始化。

- 构造方法的重载

• 构造方法与普通方法一样，都是支持重载操作的，只要参数的类型或个数不同，则就可以完成重载操作。

匿名对象的使用

1. 匿名：没有名字，在java中如果一个对象只使用一次，则称为匿名对象；
2. 所谓的匿名对象就是比之前的对象少了一个栈内存的引用关系。
3. 匿名对象只在堆内存中开辟空间，而不存在栈内存的引用。

总结：

1. 构造方法的定义及使用原则：
2. 对象实例化时必须调用构造方法
3. 每个类中都至少有一个构造方法
4. 匿名对象：只开辟了堆内存的实例对象

- 类设计分析：

• 根据需求写出类所包含的属性；
• 所有的属性都必须进行封装（private）；
• 封装之后的属性都必须通过setter和getter设置和取得；
• 如果需要可以加入若干构造方法；
• 再根据其他要求添加相应的方法；
• 类中所有的方法都不会直接输出，而是交给北调用处输出。

- String 类：（比较重要）

string有两种比较方式：
- ==用来判断地址空间是否相等，判断的是地址值，比较的地址值；
- 如果判断内容相等与否，则就使用equals（）方法来比较；

- String类的两种实例化方式

在String 中可以直接赋值和new 调用构造方法的方式完成，
String name = “skye”;
表示将一个堆内存空间的指向给了栈内存空间；

- String类的两种比较操作

• 使用直接赋值的方式，只需要一个实例化对象即可，可以有效的节省内存空间，

• 使用new String（）的方式，开辟了两个内存对象，开发中最好使用直接赋值的方式完成。
  String的特点：

  1. 字符串的内容不可改变；改变的是堆内存地址的指向（内存地址的引用关系）；
  2. StringBuffer()；
-

- String 的常用方法：

语言的使用文档，，为用户列出了全部的类以及相关的操作及使用方法；

- 字符串与字符数组

一个字符串可以变为一个字符数组，同样，也可以把一个字符数组变为一个字符串。
在String类中提供了以下方法：
1. 将字符串变为字符数组：public char[] toCharArray()
2. 字符数组变为字符串：public String(char[] value) 和
3. public String(char[] value,int offset,int count)

- 从字符串取出指定位置的字符

此方法的返回值一定是一个char类型，public char charAt(int index)

public class StringAPIDemo{
public ststic void main(String args[]){
    String str1 = "hello";
    System.out.pringln(str1.charAt(3));
    }
}   

- 字符串与byte数组的转换：

byte数组（字节数组），一般在IO操作中会经常使用到。

1. 字符串变为字节数组：public byte[] getBytes(）

2. 将一个字节数组变为字符串：

3. 将全部字节数组变为String：public String(byte[] bytes)

4. 将部分字节数组变为String：public String(byte[] bytes,int offset,int length)

- 取得一个字符串的长度：public int length()

    public class StringAPIDemo{
    public ststic void main(String args[]){
        String str1 = "hello skye";
        System.out.pringln("\""+str1+"\"的长度为：”str1.length());
        }
    }

注意：

• 在数组中可以使用数组名称.length，而在字符串的操作中一定要记得用（）：字符串.length（）；

- 查找指定的字符串是否存在：

1. 从头开始查找：public int indexOf(String str)

2. 从指定位置开始查找：public int indexOf(int ch,int fromIndex)

   • 查找的时候方法的返回值是一个字符串的位置，如果查到的话返回字符串的位置，如果没有查到的话，他将返回-1；

- 去掉空格：

• 如果信息由用户输入，可能有空格，需要去掉左右两边的空格，但是在字符串之间的空格是不能去掉的

- 字符截取：

从一个指定的字符串中取出里面的部分内容，

使用方法：

• 从指定位置开始一直截取到结束位置：public String substring(int beginIndex)

• 截取指定范围的字符串：public String substring(int beginIndex, int endIndex)

- 拆分字符串：

需要按照指定的字符串去拆分一个字符串：public String[] split(String regex)

- 大小写转换：

转化为大写：public String toUpperCase()

转化为小写：public String toLowerCase()

- 判断是否以指定的字符串开头或结尾：

public boolean startsWith(String prefix)测试此字符串是否以指定的后缀开始。

public boolean endsWith(String suffix)测试此字符串是否以指定的后缀结束。

- 不区分大小写的比较：

equals只能对大小写一致的字符串进行比较，
public boolean equalsIgnoreCase(String anotherString)将此 String 与另一个 String 比较，不考虑大小写。如果两个字符串的长度相同，并且其中的相应字符都相等（忽略大小写），则认为这两个字符串是相等。的。

- 引用传递

- this 关键字

1. 表示类中的属性：
2. 使用this调用构造方法：

3. 使用this表示当前对象：

   当前对象：当前正在调用方法的对象。

- java集合

作用：存放对象，有时候是容器。

1. 数组：缺陷—类型单一，固定长度，无法更改不能知道数组中对象的真实数量。

2. 集合：可变容量的数组，java.util.collection –接口,表示集合

   list 接口 有顺序，可以重复

   set 接口 没有顺序，不可重复

   map 接口 不是collection的子接口，名值对，一次保存2个对象，前面的对象是KEY，后面的对象为value，根据key来获取value。key 不可重复，value可以重复。

类的关系图：

1.向集合中添加对象

collection c1 = new ArryList();
//

• boolean add(E e)–向列表的尾部添加指定的元素（可选操作）。
• boolean 表示是否成功加入。
  c1.add(“hello”);
  c1.add(new Integer(1));

2.将一个集合中所有的对象加入到另一个集合

collection c2 = new ArryList();

3.清除集合中所有的对象
void clear()

4.比较集合中是否包含指定的对象
boolean contains(Object o)

5.比较集合中是否包含另一个集合的所有内容
boolean containsAll(Collection

package com.skye;

    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;

    /*
     * 用一个集合保存十份学生成绩，输出其中不及格的成绩。*/

    public class StudentScore {
        public static void main(String[] args) {

            Collection score = new ArrayList();
            score.add(11);
            score.add(79);
            score.add(80);
            score.add(92);
            score.add(87);
            score.add(79);
            score.add(90);
            score.add(59);
            score.add(60);
            score.add(77);
            //迭代器来遍历集合
            Iterator it = score.iterator();

            while(it.hasNext()){
                Integer i = (Integer)it.next();
                if(i<60){
                    System.out.println(i+"");

                }

            }

        }

    }

- List

ArryList –使用数组来实现，
特点：

1. 访问元素 快速，改变集合效率低（增加，删除，插入较多）
2. 按照序列进行访问的操作多，改变集合内容的操作少的情况下，选择使用该类
3. 最常使用LIst集合

- LinkedList

特点：

1. 修改集合内容效率高，（增加，删除，插入），资源利用率高
2. 根据序列访问效率比较低；
3. 修改操作频繁，根据序列查询操作少，选择使用该类

- Vector

• 古老的list，线程安全，效率低，速度慢

  public class CollectionDemo{
  public ststic void main(String args[]){
  //List 集合 （有序可重复）
  List list = new LinkedList();

  //向List 集合中添加对象，对象的顺序按照添加的顺序
  //序列从0开始
  list.add("hello");
  
  list.add("world");
  list.add("hello");
  //2.可以为新添加的对象指定添加的位置
  list.add(1,"hehe");
  
  //3.根据对象的序列获取对象
  System.out.println(list.get(1));
  
  //4.返回此列表中第一次出现的指定元素的索引
  System.out.println(list.IndexOf("hello"));
  
  //5.替换list集合的对象
  list.set()1,"haha";
  System.out.println(list.get(1));
  System.out.println(list.get(2));
  //6.返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图
  List newList = list.subList(0,3);
  System.out.println(newList.size());
  
  Iterator it = list.iterator();
  while(it.hasNext()){
      Systom.out.println(it.next());
      }
  }
  }
  

collections类–一个工具类

集合的工具类—工具类：其中的方法都是static静态的方法
使用：

1. reverse(List list)：反转 List 中元素的顺序

2. sort(List list)：根据元素的自然顺序对指定 List 集合元素按升序排序
   //按照对象的自然顺序来排列，（也可以自定义顺序）
   Collections.sort(list);
   it.list.iterator();
   while(it)

3. Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素

4. void copy(List dest,List src)：将src中的内容复制到dest中

练习：

package com.skye1;
/*
 * 1.一个饲养员给动物喂食物的例子体现JAVA中的面向对象思想,接口（抽象类）的用处
 */

//1.动物接口  -- interface
interface Animal{
    public void eat(Food food);

}
// 第一种动物  -- 狗
class Dog implements Animal{

    @Override
    public void eat(Food food) {
        System.out.println("狗啃"+food.getName());

    }

}

// 第二种动物  -- 猫
class Cat implements Animal{

    @Override
    public void eat(Food food) {
        System.out.println("猫吃"+food.getName());

    }

}

//2. 食物抽象类  -- abstract
abstract class Food {
    protected String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

//第一种食物  -- 鱼
class Fish extends Food{

    public Fish(String name) {
        super();
        this.name = name;

    }

}

// 第二种食物  -- 骨头
class Bone extends Food{

    public Bone(String name) {
        super();
        this.name = name;
    }

}

//4. 饲养员类 -- 
class Feeder{

    //有一个喂养的方法
    public static void feed(Animal animal,Food food){
        animal.eat(food);

    }

}                   

//5. 测试类 -- 饲养员给动物喂食物
public class TestFeeder {

    public static void main(String[] args) {
        Feeder feeder = new Feeder();

        Animal animal = new Dog();
        Food food = new Bone("骨头"); //给狗喂肉骨头
        Feeder.feed(animal,food);

        animal = new Cat();
        food = new Fish("鱼");
        Feeder.feed(animal, food); //给猫喂鱼


    }

}