目录
一、什么是面向对象
以类的方式组织代码，以对象的形式封装数据
三大特性：封装、继承、多态
二、类与对象
1 类与对象关系
类：是对象共同特征的描述
对象：是真实存在的具体实例
类名首字母大写；实际开发中建议一个文件定义一个class类
2 对象的创建
public class 类名 {
1、成员变量
2、成员方法
...
}类名 对象名 = new 类名();对象.成员变量；
对象.成员方法（xxx）；
3 构造方法
作用：在创建对象的时候给成员变量进行赋值的
- 方法名与类名相同，大小写也一致
- 没有返回值类型，连void都没有
- 没有具体的返回值
public class Person {
//一个类即使什么都不写，它也会存在一个方法
//显示的定义构造器
String name;
//实例化初始值
//1.使用new关键字，本质是在调用构造器
public Person(){
// this.name = "张三";
}
//有参构造:一旦定义了有参构造，无参就必须显示定义
public Person(String name){
this.name = name;
}
}//一个项目应该只存一个main方法
public class Application {
public static void main(String[] args) {
//new实例化了一一个对象
Person person = new Person("李四");
System.out.println(person.name);
}
}4 JavaBean类
- 类名需要见名知意
- 成员变量使用private修饰
- 提供至少两个构造方法
- 无参构造方法
- 带全部参数的构造方法
成员方法
- 提供每一个成员变量对应的setxx()/getxxx()
- 如果还有其他行为，也需要写上
三、面向对象三大特征
1 封装
“高内聚，低耦合”。高内聚：就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
对象代表什么，就得封装对应的数据，并提供数据对应的行为。
// Student类
public class Student {
//属性私有
private String name;//名字
private int age;//年龄
private int idCard;//学号
private char sex;//性别
//提供一些可以操作这个属性的方法!
//提供一些public 的get、set方法
//get获得这个数据
public String getName() {
return name;
}
//set给这个数据设置值
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age>120||age<0){ //不合法
this.age = 3;
}else{
this.age = age;
}
}
public int getIdCard() {
return idCard;
}
public void setIdCard(int idCard) {
this.idCard = idCard;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
}// Application类
public class Application {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("李白");
System.out.println(s1.getName());
s1.setAge(99);
System.out.println(s1.getAge());
}
}2 继承
extends
public class student extends Person{}Student称为子类，Person称为父类
- 子类可以得到父类的属性和行为，子类可以使用。
- 子类可以在父类的基础上新增其他功能，子类更强大。
- java只支持单继承，不支持多继承，但支持多层继承
子类到底能继承父类中的哪些内容：
- 构造方法 非私有 不能 private 不能
- 成员变量 非私有 能 private 能
- 成员方法 非私有 能 private 不能
方法的重写
- 当父类的方法不能满足子类现在的需求时，需要进行方法重写
- 在继承体系中，子类出现了和父类中一模一样的方法声明，我们就称子类这个方法是重写的方法。
- @Override是放在重写后的方法上，校验子类重写时语法是否正确
注意事项：
- 重写方法的名称、形参列表必须与父类中一致
- 子类不能继承父类的构造方法，但是可以通过super调用；
- 子类构造方法的第一行，有一个默认的super();
- 默认先访问父类中无参的构造方法，再执行自己；
super和this
- this：理解为一个变量，表示当前方法调用者的地址值
- super：代表父类存储空间，直接访问父类的
3 多态
同类型的对象，表现出的不同形态
父类类型 对象名称 = 子类对象
前提：
- 有继承关系
- 有父类引用指向子类对象
- 有方法重写
- 参数：编译看左边运行看左边
- 方法：编译看左边运行看右边
优势：
- 在多态形式下，右边对象可以实现解耦合，便于扩展和维护；
- 定义方法的时候，使用父类型作为参数，可以接收所有子类对象，体现多态的扩展性与便利
弊端：
- 不能使用子类的特有功能
- 可以进行强制类型转换来进行访问子类独有功能。
- Animal a = new Dog();
- Dog d = (Dog) a;
- 转换类型与真实对象类型不一致会报错，转换的时候用instanceof关键字进行判断。
- 例如if(a instanceof Dog){}意思是a的类型是不是Dog
4 static
static表示静态，是java中的一个修饰符，可以修饰成员方法，成员变量
被static修饰的成员变量，叫做静态变量
特点：
- 被该类所有对象共享
- 不属于对象，属于类
- 随着类的加载而加载，优先于对象存在
- 类名调用/对象名调用
被static修饰的成员方法，叫做静态方法
特点：
- 多用在测试类和工具类中
- javabean类中很少会用
- 类名调用
注意事项：
- 静态方法只能访问静态变量和静态方法
- 非静态方法可以访问静态变量或者静态方法，也可以访问非静态的成员变量和非静态的成员方法
- 静态方法中是没有this关键字
四、抽象类与接口
1 final
final关键字是最终的意思，可以修饰：类、方法、变量
- 修饰类：该类被称为最终类，特点是不能被继承
- 修饰方法：该方法被称为最终方法，特点是不能被重写了
- 修饰变量：该变量有且仅能被赋值一次。
2 单例类
设计模式
一个问题通常有n种解法，其中肯定有一种解法是最优的，这个最优的解法被人总结出来了，称之为设计模式。
设计模式有20多种
单例设计模式：
作用：确保某个类只能创建一个对象。
饿汉式单例类
写法：
- 把类的构造器私有
- 定义一个类变量记住类的一个对象
- 定义一个类方法，返回对象
//设计成单例设计模式
public class A {
//2、定义一个静态变量，用于基本本类的一个唯一对象
private static A a = new A();
//public static int a1 = 20;
//1、私有化构造器：确保单例类对外不能创建太多对象，单例才有可能性
private A() {
}
//3、提供一个公开静态方法，返回这个类的唯一对象
public static A getInstance() {
return a;
}
}懒汉式单例类
用对象时，才开始创建对象
写法：
- 把类的构造器私有
- 定义一个静态变量用于存储对象
- 提供一个静态方法，保证返回的是同一个对象
//懒汉式单例类
public class B {
//2、私有化静态变量
private static B b;
//2、私有化构造器
private B() {
}
//3、提供静态方法返回对象，真正需要对象的时候才开始创建对象
public static B getInstance() {
if (b == null){
b = new B();
}
return b;
}
}3 枚举类
枚举是一种特殊类
枚举类的写法
修饰符 enum 枚举类名{
名称1， 名称2，...;
其他成员...
}
特点：
- 枚举类中的第一行，只能写枚举类的对象名称，且要用逗号隔开
- 这些名称，本质是常量，每个常量都记住了枚举类的一个对象
- 枚举都是最终类，不可以被继承，枚举类都是继承java.lang.Enum类的
- 枚举类的第一行只能罗列一些名称，这些名称都是常量，并且每个常量会记住枚举类的一个对象
- 枚举类的构造器都是私有的
- 适合做信息分类和标志
4 抽象类
abstract
修饰类，就是抽象类
修饰方法，就是抽象方法
修饰符 abstract class 类名{
修饰符 abstract 返回值类型 方法名称（形参列表）；
}
抽象类不能创建对象，仅作为一种特殊的父类，让子类继承并实现
一个类继承抽象类，必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类
为了更好地支持多态
模板方法设计模式
两个类同一个方法只有部分不同，可用抽象方法来进行优化
public abstract class People {
public void write(){
句子1;
句子2;
writeMain();
句子3;
句子4;
}
public abstract void writeMain();
}5 接口
java提供了一个关键字interface定义出接口
public interface 接口名 {
//成员变量（常量）
//成员方法（抽象方法）
}接口不能创建对象
接口是用来被类实现的，实现接口的类称为实现类，一个类可以同时实现多个接口
修饰符 class 实现类类名 implements 接口1， 接口2， 接口3，...{
//实现类实现多个接口，必须重写完全部接口的全部抽象方法，否则实现类需要定义成抽象类
}实现类实现多个接口，必须重写完全部接口的全部抽象方法，否则这个类必须定义成抽象类
好处：
- 弥补了类单继承的不足，一个类同时可以实现多个接口，使类的角色更多，功能更强大
- 让程序可以面向接口编程，这样程序员就可以灵活方便的切换各种业务实现（更利于程序的解耦合）
三种新方法：
- 默认方法（实例方法）
- 私有方法
- 类方法（静态方法）
public interface A {
//1、默认方法（普通实例方法）：必须加default修饰，
//默认会加public修饰
//使用接口的实现类的对象来实现调用
default void go(){
...
run();
}
//2、私有方法
//私有的实例方法
//使用接口中的其他实例方法来调用
private void run(){
...
}
//3、静态方法
//默认会用public来修饰
//只能使用当前接口名来调用
static void show(){
...
}
}抽象类与接口的区别
相同点：
- 都是抽象形式，都可以有抽象方法，都不能创建对象
- 都是派生子类形式：抽象类是被子类继承使用，接口是被实现类实现
- 一个类继承抽象类，或者实现接口，都必须重写完他们的抽象方法，否则自己要成为抽象类或者报错
- 都能支持的多态，都能够实现解耦合
不同点：
- 抽象类中可以定义类的全部普通成员，接口只能定义常量，抽象方法
- 抽象类只能被类单继承，接口可以被实现类多实现
- 一个类继承抽象类就不能再继承其他类，一个类实现了接口还可以继承其他类或者实现其他接口
- 抽象类体现模板思想：更利于做父类，实现代码的复用性
- 接口更适合做功能的解耦合：解耦合性更强更灵活。
五、内部类
类的五大成分：成员变量、构造器、方法、代码块、内部类
代码块
代码块分为两类：
静态代码块：
- 格式：static{}
- 特点：类加载时自动执行，由于类只会加载一次，所以静态代码块也只会执行一次
- 作用：完成类的初始化，例如：对静态变量的初始化赋值
public class CodeDemo {
static {
...
}
public static void main(String[] args) {
...
}
}实例代码块：
- 格式：{}
- 特点：每次创建对象时，执行实例代码块，并在构造器前执行
- 作用：和构造器一样，都是用来完成对象的初始化的，
内部类
如果一个类定义在另一个类的内部，这个类就是内部类
当一个类的内部，包含了一个完整的事物，且这个事物没有必要单独设计时，就可以把这个事物设计成内部类。
成员内部类
就是类中的一个普通成员，类似普通的成员变量、成员方法。
成员内部类创建对象的格式：
外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称()
Outer.Inner oi = new Outer().new Inner();public class Outer {
private String name;
//构造器
public Inner() {
System.out.println("Inner()");
}
//有参数构造器
public Inner(String name) {
this.name = name;
System.out.println("Inner(String name)");
}
public void show() {
...
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}特点：
- 成员内部类中可以直接访问外部类的静态成员，也可以直接访问外部类的实例成员
- 成员内部类的实例方法中，可以直接拿到当前寄生的外部类对象，外部类名.this。
静态内部类
有static修饰的内部类，属于外部类自己持有
public class Outer{
//静态内部类
public static class Inner{
}
}外部类名.内部类名 对象名 = new 外部类.内部类();
Outer.Inner in = new Outer.Inner();局部内部类
局部内部类是定义在方法中、代码块中、构造器等执行体中
匿名内部类
是一种特殊的局部内部类
指的是程序员不需要为这个类声明名字，默认有个隐藏的名字
new 类或接口（参数值） {
类体（一般是方法重写）;
};
new Animal() {
@Override
public void cry() {
}
};特点：匿名内部类本质就是一个子类，并会立即创建出一个子类对象。
作用：用于更方便的创建一个子类对象。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
