java 面向对象

Java 面向对象

什么是重复造轮子?
利用已有资源，实现自己目的。而自己不必去实现每一个细节。前提是，得会用已有资源。

package com.curtis;
public class TestClass {
    public static void main(String[] args) {
        Student st1 = new Student();
        st1.setName("Curtis");
        st1.getInfo();
    }
}


class Person {
    private String id;
    private String name;
    private String sex;
    private Integer age;

    public Person() {

    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

class Student extends Person {
    private String school;

    public Student() {
    }

    public void getInfo() {
        System.out.println(getName());
    }

    public String getSchool() {
        return school;
    }

    public void setSchool(String school) {
        this.school = school;
    }

}

观察上面代码：
Student 类的实例可以使用Person 类中的方法 setName(String name)

数据库：存储数据的仓库

1、二维表结构
2、表中的一行数据

简单java 类
略，上面Person 示例就是。

为什么会用到简单java类?
1、表中的一行记录可以用一个实例对象表示。实例对象是类通过实例化来的。所以类的定义得参考表中的字段。

package com.curtis;
public class TestClass {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.setId("10000");
        p1.setName("Curtis");
        p1.setAge(25);
        p1.setSex("男");
        System.out.println(p1.getInfo());
    }
}

class Person {
    private String id;
    private String name;
    private String sex;
    private Integer age;

    public Person() {

    }

    public String getInfo() {
        return "编号：" + this.getId() + "、姓名：" + this.getName() + "、年龄：" + this.getAge() + "、性别：" + this.getSex();
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

简单java 类
1、包
2、定义类
2.1、访问修饰符
2.2、关键字 class
2.3、类名称
3、类中的属性
3.1、访问修饰符
3.2、强类型的编程语言都需要给变量声明数据类型;
4、对象通过方法的调用给属性赋值，对象通过方法的调用从对象中取出值
4.1、方法的定义
4.1、访问修饰符public private protected
4.2、方法执行完是否会有内容返回(决定是否有return)
4.3、方法的名称
4.4、方法的参数列表，是一个还是多个
4.5、static 方法
4.6、方法的重载(方法名称相同，参数列表不同[参数数据类型，参数个数])
4.7、方法的覆写(有一个前提，继承关系)
4.8、普通方法、static 方法调用方式
4.2、方法的调用
5、构造方法
5.1、为对象进行初始化

普通方法跟static方法
1、普通方法是类的对象进行调用。在类内部可以相互调用。
2、static方法属于类，不是某个类的实例的。
注意点：普通方法中能够调用static 方法么？答案是：可以。那static 方法能够直接调用普通方法么？答案是：不可以。
普通方法要通过类的实例进行调用，static 方法调用方式：类名.static方法名。如果在static 方法中对普通方法进行调用，类的实例不存在该如何处理。

类跟对象
以汽车为例
1、汽车的设计图纸
2、汽车零件
3、汽车

类是，类对象的类型
Person 自定义类
Person p1=new Person();
String 编程语言定义的类
String name=“Curtis”;name 的类型是字符串。p1 的类型是Person类

构造方法
类文件–>内存 实例化，通过构造方法。

什么叫做实例化?
程序员编写的是.java 文件,要想用这个.java 文件,必须要到内存中去,从.java 到内存中的过程可以想象成是在实例化(说法并不标准,但是可以这样理解);

static方法调用的方式:
1、在同一个类中,直接调用
2、在一个类中想调用其它类中的static方法:类名称.static方法名称

为什么要有static 呢?
以数据库的打开,关闭为例;
如果将数据库的打开关闭操作都定义成普通方法,那么在调用打开,关闭方法时,都需要通过类创造一个对象实例出来。

什么是类对象？static 内容就是属于类的。
什么是实例对象？属性，普通方法是类的实例进行调用的，属于实例对象。

package com.curtis;
public class TestClass {
    public static void main(String[] args) {
        say();
    }

    public static void say(){
        System.out.println("hello world");
    }
}

继承(对类功能的扩充)，关键字extends。

是不是父类中的所有内容子类都能够使用?不是，private 修饰的内容子类是无法使用的;

方法的重载与方法的重写
1、同一个类中方法名称相同,方法的参数列表不同,这样现象称之为方法大的重载
2、方法的重写,前提:必须要有继承关系
重写：继承类在使用被继承类中的方法时，发现被继承类中的方法无法满足要求。

多态
Person p2=new Student();
父类引用指向子类实例化对象;

this关键字
指代本类

package com.curtis.bean;
public class Person {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

name 是Person的一个属性
方法内的this.name 表示的是当前这个类里面的东西,而右边的name是方法的参数传进来的;

super关键字
有个前提:存在继承关系
继承类使用被继承类中的方法。为了说明是被继承类中的方法,还能用在构造方法上面;

继承关系里面实例化继承类时跟被继承类是否有关联？
有
在实例化集成类过程中,会先调用被继承类中无参数的构造方法;

Person p3=new Person();
p3.setName("Curtis");

System.out.println(p3.getName());

上述代码：
实例对象调用方法，传了个参数。是往实例对象中设置值，实例对象不被垃圾回收机制回收，就是有效的。实例对象通过方法调用，取值出来。

无参数的构造方法
1、按照编程语言语法声明一个类,如果不显示定义构造方法,那么语法会自动隐含声明一个无参数的构造方法
2、如果显示的定义了一个有参数的构造方法,那么语法不会声明一个无参数的构造方法了
3、构造方法的作用是给类中的属性进行赋初值
4、构造方法是一中特殊的方法,方法名称与类名称相同
5、构造方法也能重载
6、如果在类的声明中,自己已经定义了一个有参数的构造方法,那就务必显示声明一个无参数的构造方法,跟反射有关系的

package com.curtis.bean;
public class Person {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    // 无参数的构造方法
    public Person(){}

    // 有参数的构造方法
    public Peron(String name){
        this.name=name;
    }
}

抽象类
1、抽象类用到了关键字abstract
2、抽象类跟普通的类区别
2.1、抽象类比普通类多了个抽象方法(抽象方法是没有方法体的,也就是没有{})
2.2、抽象类不能被实例化
2.3、抽象类是给普通类去继承的
2.4、普通类继承了抽象类,必须覆写(重写)抽象类中的抽象方法
2.5、抽象类中的抽象方法就是给出方法的标准
2.6、类的继承用extends关键字
2.7、一般不建议继承一个已经实现好的类,当然语法上面是没有错误的
2.8、既然抽象类是给普通类定义标准,那么抽象类中抽象方法绝对不能使用private关键字修饰
2.9、如果类中有些方法不希望子类进行覆写,那么可以使用final 关键字修饰

接口
implement
面向接口编程是java 里面一个比较有意思的
1、抽象类能够实现接口,接口中定义的方法,抽象类中并不一定要提供提具体实现(抽象类中能定义抽象方法嘛)
2、普通类既继承了抽象类,又实现了某个接口,先继承,后实现接口,也就是写法上是:类 extends 抽象类 implement 接口
案例：public class MemberDAOImpl extends AbstractDAO implements IMemberDAO{}
3、接口里面只有常量、抽象方法
4、普通类实现接口必须实现接口中定义的抽象方法
5、接口也是一种特殊的类,所以接口对象,能够指向普通类的实例