面向对象初总结

第一次写博客，欢迎各路大神指点初错误之处

首先，面向对象的基本思想是，从现实世界中客观存在的事物出发来构造软件系统，尽可能多的使用人类的思想方式。
对象和类：
简单的来说，类是一类对象的模板，对象是该类一个具体实例。

类	对象
学生	学生张三
学号	123456
-姓名-	-张三-
方法：显示姓名	输出“姓名：张三”

而类与类之间又存在一些不可告人的关系：
关联关系：学校->老师->学生（学校与学生也有关联关系）
继承关系：动物->猴类->金丝猴
聚集关系：球队队长和队员组成了球队，称为聚集。
组合关系：人由头，手，脚，身体，组成，缺一不可。
聚集和组合统称为聚合关系。
多态关系：交通工具可分为汽车，摩托车，单车，每种车类都有自己的属性和方法，这些车类的方法相似而不相同，汽车和摩托车都可以刹车，但具体的实现方式却不同。
…
Java关键字：class！
可以利用class定义一个类，具体代码下面给出。
定义一个类需要赋予该类以成员变量（本身具有的属性）和方法（函数）。

成员变量：

1. 可以使用Java中任意一种数据类型。
2. 在定义时可以对其进行初始化。如果不对其进行初始化，Java默认的对其初始化。
   

Java基本概念-引用

1. Java中除了基本类型之外的变量类型都称之为引用类型。
2. Java中的对象都是通过引用对其操作的。

对象的创建和使用

1. 必须使用new关键字创建对象
2. 使用引用.成员变量来引用对象的成员变量
3. 使用引用.方法来调用对象的方法
4. 同一个类的对象都有不同的成员变量来存储空间
5. 同一个类的每个对象共享该类的方法
   代码示例：

//定义一个猫类
class Cat{
    //定义猫的属性（成员变量），名字和颜色
    public String name;
    public String color;
    
    //定义猫的方法
    public void setName(String n, String c){
        name = n;
        color = c;
    }
}

public class TestObject {
    public static void main( String[] args ){
        Cat cat1 = new Cat();//创建Cat对象
        Cat cat2 = new Cat();
        cat1.name = "小可爱";//利用引用.成员变量来调用该对象的成员变量
        System.out.println(cat1.name);

        cat1.setName("小恶魔", "黑色");//利用引用.方法来调用该类的方法
        System.out.println(cat1.name);
        System.out.println(cat1.color);

        cat2.setName("小天使", "白色");//该类的每个对象共享该类的方法
        System.out.println(cat2.name);
        System.out.println(cat2.color);
    }
}

编译结果

小可爱
小恶魔
黑色
小天使
白色

Process finished with exit code 0

构造方法

1. 使用new+构造方法创建一个新的对象
2. 构造函数是定义在Java类中的一个用来初始化对象的函数
3. 构造函数与类同名且没有返回值
4. 当没有指定构造函数时，编译器为类自动添加形如 类名 (){} 的构造函数
5. 构造方法可以构成重载：也就是具有多个名字相同，但参数不同的方法。（当然构造函数的名字与类相同，普通方法也可以构成重载）

//定义一个猫类
class Cat{
    //定义猫的属性（成员变量），名字,颜色,重量
    public String name;
    public String color;
    double weight;

    //定义猫的构造方法
    Cat(String n){
        name = n;
    }
    //构造方法的重载
    Cat(String n, String c){
        name = n;
        color = c;
    }
    //构造方法的重载
    Cat(String n, String c, double w){
        name = n;
        color = c;
        weight = w;
    }
    //获得猫的名字
    public String getName() {
        return name;
    }
    //获得猫的颜色
    public String getColor(){
        return color;
    }
    //获得猫的重量
    public double getWeight(){
        return weight;
    }
}

public class TeatConstructFunction {
    public static void main( String[] args ){
        Cat cat1 = new Cat("小可爱");//调用的是第一个构造方法
        Cat cat2 = new Cat("大可爱", "黄色");//调用的是第二个构造方法
        Cat cat3 = new Cat("不可爱", "绿色", 8.3);//调用的是第三个构造方法

        System.out.println("我是第一只猫，我调用了第一个构造函数！我叫："+cat1.getName());
        System.out.println("我是第二只猫，我调用了第二个构造函数！我叫："+cat2.getName()+"，我的颜色是："+cat2.getColor());
        System.out.println("我是第三只猫，我调用了第三个构造函数！我叫："+cat3.getName()+"，我的颜色是："+cat3.getColor()+",我的体重是："+cat3.getWeight());
    }
}

编译结果

我是第一只猫，我调用了第一个构造函数！我叫：小可爱
我是第二只猫，我调用了第二个构造函数！我叫：大可爱，我的颜色是：黄色
我是第三只猫，我调用了第三个构造函数！我叫：不可爱，我的颜色是：绿色,我的体重是：8.3

Process finished with exit code 0

this 关键字

1. 在类的方法定义中使用的this关键字代表使用该方法的对象的引用
2. 必须指出当前使用方法的对象是谁要使用this
3. 有时使用this可以处理方法中成员变量和参数重名的情况
4. this可以看作是一个标量，他的值是当前对象的引用

public class TestThis {
    public static void main(String[] args) {
        Leaf leaf = new Leaf(100);//调用构造方法，传入i的值
        leaf.increament().f();//先调用了increament方法，返回一个this（指向当前对象的引用）this再调用了f函数输出i的值
    }
}
class Leaf{
    int i;

    Leaf(int i){
        this.i = i;//this指向当前对象，返回this
    }
    //建立一个返回类型为Leaf的increament函数 
    Leaf increament(){
        i++;
        return this;//this指向当前对象（当前对象为Leaf类型），返回当前对象
    }
    
    void f(){
        System.out.println("i="+i);
    }
}

编译结果

i=101

Process finished with exit code 0

static 关键字

1. 在类中，用static申明的成员变量为静态成员变量，他是该类的公用变量，在第一次使用时被初始化，对于该类的所有对象来说static变量只有一份
2. 用static声明的方法为静态方法，在调用该方法时，不会将对象的引用传递给它，所以在static方法中不可以访问非static的成员
3. 可以在通过对象引用或类名（不需要实例化）访问静态成员

public class TestStatic {
    public static void main(String[] args){
        Dog.i = 100;//i被赋值为100
        Dog dog1 = new Dog ("alan");
        Dog  dog2 = new Dog ("Bob");
        dog1.info();
        dog2.info();
        System.out.println("i最后为："+Dog.i);
    }
}

class Dog{
    public static int i = 0;//i是静态变量，存储于数据区
    public String name;
    int id;

    Dog (String name){
        this.name = name;
        id = i++;//第一次调用此方法时：id=i之后，i才自增，这时id=100，i=101，同理，第二次id=101，i=102
    }

    public void info(){
        System.out.println("My name is:"+name+"No."+id);
    }
}

编译如下

My name is:alanNo.100
My name is:BobNo.101
i最后为：102
Process finished with exit code 0

import语句

1. 可以用import在文件的开头引入要使用的类

package com.dajiao.Import;

import java.io.BufferedReader;
import java.io.InputStreamReader;//用import语句输入功能的类

public class TestImport {
    public static void main(String[] args) throws Exception{
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));//建立输入对象
        int i,sum=0;
        for(i = 0; i < 5; i++) {
            String s = bufferedReader.readLine();//输入字符串
            int a = Integer.parseInt(s);//将字符串转换为整型数据
            sum =sum +a;//计算总和
        }
        System.out.println("sum="+sum);
    }
}

1
2
3
4
4
sum=14
``
类的继承

1. Java中使用extends关键字来实现类的继承机制
2. 通过继承，子类自动拥有了基类的所有成员（成员变量和方法）
3. Java只支持单继承，不支持多继承

方法的重写

4. 在子类中根据需要对从基类中继承来的方法来进行重写
5. 重写的方法必须和被重写方法有相同的名称，参数列表和返回类型
6. 重写方法不能比被重写方法有更严格的访问权限

super关键字

7. 在Java中使用super来引用基类的成分

继承中的构造方法

1.子类的构造的过程必须调用基类的构造方法
2.子类可以在自己的构造方法中使用super关键字来调用构造方法
3.可以使用this关键字来调用本类的其他的构造方法
4.如果子类的构造方法中没有显示地调用基类的构造方法，则系统默认调用基类无参数的构造方法
5.如果子类构造方法没有显示的调用构造方法，而基类中又没有无参数的构造方法，则编译出错

package com.dajiao.Extendsone;

class Person{
    public String name;
    int age;
    /*Person(String name, int age){
        this.name = name;
        this.age = age;
    }*/

    Person(String name, int age){
        this.name = name;
        this.age = age;
    }

    public String info(){
        return "name:"+name+" "+"age:"+age;
    }
}
//student继承Person
class Student extends Person{
    public String job;       //增加了成员变量，同时拥有父类的成员变量

    Student(String a, int b, String c){
        super(a,b);          //如果注释掉此语句的话，系统将会报错
        this.job = c;
    }

    public String info(){
        return super.info()+" "+"job:"+job;
    }
}

public class Extends {
    public static void main(String[] args){
        Person per = new Person("alan",25);
        Student stu = new Student("bob",25,"学生");
        System.out.println(per.info());
        System.out.println(stu.info());
    }
}

编译结果

name:alan age:25
name:bob age:25 job:学生

Process finished with exit code 0

对象转型

1. 一个基类的引用类型变量可以指向其子类的对象
2. 一个基类的引用不可以访问其子类对象新增加的成员（属性和方法）

多态

3. 要有继承
4. 要有重写
5. 父类对象指向子类对象（简单的来说，是定义一个总类，总类是一个抽象类（abstract），其方法也是抽象的，不能调用对象使其实例化，其子类继承他的方法，然后重写，进行实例化）
6. 多态是为了对对象转型更加简便

接口

1. 多个无关的类可以实现同一个接口
2. 一个类可以实现多个无关的接口
3. 与继承关系类似，接口与实现类之间存在多态性
4. 接口中声明默认为public static final（不可更改），也只能是public static final 的
5. 接口中只能定义抽象方法，而且这些方法默认为public的，也只能是public的
6. 接口之间可以继承，并添加新的属性和抽象方法

package com.dajiao.Interface;

public class Testinterface {
    public static void main(String[] args){
        Valuable v = new GoldMonkey();
        System.out.println("价值："+v.getMoney()+"人名币！");//由于new了一个GoldMonkey对象，但引用是“价值”接口的，只能调用从“价值”接口中得来的方法
        Protectable p = (Protectable)v;                   //将“价值”引用强制转换为“保护”引用
        p.getPro();                                       //调用从“保护”接口中得来的方法
        Animal a = new GoldMonkey();                      //强制转换为Animal引用 
        a.enjoy();                                        //调用从抽象类Animal中继承的方法
    }
}
//定义一个“价值”接口
interface Valuable{
    public int getMoney();
}
//定义一个“保护”接口
interface Protectable{
    public void getPro();
}

interface A extends Protectable{
    void m();
}
//定义一个抽象类
abstract class Animal{
    private String name;
    abstract void enjoy();
}
//定义一个GoldMonkey类，继承了Animal类，“价值”接口和“保护”接口，此时关键之不再是exends，而是implements
class GoldMonkey extends Animal implements Valuable,Protectable{
    //重写了父类Animal的方法
    public void enjoy(){
        System.out.println("哈哈哈哈......");
    }
    //重写了“价值”接口的方法
    public int getMoney(){
        return 50000;
    }
    //重写了“保护”接口的方法
    public void getPro(){
        System.out.println("不能伤害她");
    }
}

编译结果

价值：50000人名币！
不能伤害她
哈哈哈哈......
Process finished with exit code 0

实在是太长了，最后的的地方有点偷懒，希望各路大神能指出我的错误之处。我是观看马士兵老师的视频学的面向对象，其中的内存分析才是最精华的地方，但内存图画起来太麻烦了，可能要花更久的时间，哈哈哈哈哈！