面向对象，class类，声明类，属性方法，掌握声明类，使用类，导入import 类，实例化对象，继承

面向对象

​ 面向对象技术利用对现实世界中对象的抽象和对象之间相互关联及相互作用的描述来对现实世界进行模拟，并且使其映射到目标系统中。其以基本对象模型为单位，将对象内部处理细节封装在模型内部，重视对象模块间的接口联系和对象与外部环境间的联系，能层次清晰地表示对象模型。

面向对象的特点为抽象性(封装性)、继承性和多态性。

java 是单继承，多实现的面向对象的高级语言。

OOP -面向对象程序设计(Object Oriented Programming)

OOD -面向对象设计（Object-Oriented Design，OOD）

AOP-面向切面编程 ( Aspect Oriented Programming)

1.class类

类和对象的概念：

类就是一块模板，确定对象将会拥有的特征（属性）和行为（方法）

具有相同属性和方法的一组对象的集合，就是类，类是抽象的。

声明类、属性、方法、初始化块可以多个、静态块也可以多个

public static void main(String[] args) {
  //类  对象(实例对象)     new实例化对象(对象可以使用)
	User     u        =    new User();
	Teacher t = new Teacher();
	User.Book book = new User().new Book();
}

1.1声明类

User.java文件有三个类外部类User、Teacher,内部类 User.Book

package cn.prictice2;

public class User {
    /*初始化程序块*/
    {for(int i = 5;i > 0; i--){
        System.out.println(i);
    }}

    /*成员 类 内部类*/
    class Book{
    }

    //对象
    //以文件形式管理信息
    //属性
    int id = 3;

    //方法
    void pring() {
    }

    /*静态程序块*/
    static {
        System.out.println("hello");
    }
    {
        System.out.println("init2");
    }

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

    }
}

1.2属性方法

访问修饰符

public private protected 保护 默认 friendly

访问修饰符	本类	同包下类	子类	其他实例对象
private private int id;	√
默认(friendly、default) int id;	√	√
protected protected int id;	√	√	√
public public int id;	√	√	√	√

package cn.practice1;

public class AccessModifier {
    /*属性 成员变量*/
    public int id; //全局
    private final int num = 18;//私有
    protected String addr = "郑州";//受保护
    String name = "jack";//友好,默认

    /* 静态属性 类变量 */
    public static int id1 = 3;
    //静态 static 只分配一次内存

    /*常量 不能修改只能使用*/
    public final int AGE = 18;
    
    public static void main(String[] args) {

    }
}

静态属性,有时候类变量只分配一次空间

public static int id1 = 3;

常量，不能修改，只能使用

public final int AGE=18;

1.4 装箱拆箱

Java中的基本数据类型不是对象型（引用类型）。但是在程序中有时需要对对象而不是基本数据类

型进行操作。因此，java里提供了一种叫做包装类(wrapper)，它能够把基本数据类型包装成对象类型。

Java中的包装器类有两个主要的作用

1. 提供一种机制，将基本值“包装”到对象中，从而使基本值能够包含在为对象而保留的操作中，或者从带对象返回值的方法中返回。
2. 为基本值提供分类功能。这些功能大多数于各种转换有关：在基本值和String 对象间相互转换，在基本值和String 对象之间按不同基数转换，如二进制、八进制和十六进制等。

基本类型	包装器类型(对象类型) valueOf() .parse()
boolean	Boolean
char	Character
int	Integer
byte	Byte
short	Short
long	Long
float	Float
double	Double

自动装箱和拆箱从Java 1.5开始引入，目的是将原始类型值转自动地转换成对应的对象。

在Java1.5下进行过编程的话，不能直接地向集合(Collections)中放入原始类型值，因为集合只接收对象。将这些原始类型的值转换成对象，然后将这些转换的对象放入集合中。使Integer,Double,Boolean等这些类我们可以将原始类型值转换成对应的对象。

Integer i = 5;//装箱操作
int n = i;//拆箱操作

5.2 package包

包package的作用：

1. 组织相关的源代码文件
2. 不同包中的类名可以相同，用来避免名字冲突
3. 提供包一级的封装和存取权限

定义包名的语法：package 包名;

eg：package cn.prictice;

注意

• 定义包的语句必须放在所有程序的最前面
• 包定义语句不是必须的，如果没有定义包，则当前编译单元属于无名包，生成的class文

件放在一般与.java文件同目录。

• Java编译器会自动引入包java.lang同包下的内容，对于其他的包，如果程序中使用

到包中的类，则必须使用import引入。

java 是单继承，多实现，每个java类，都会默认继承Object类

java.lang包下的所有类和同包下的类(java.lang.String java.lang.System类),在程序运行时，不用导入直接使用

abc公司
abc.com
    
oa项目
com.abc.oa.ui
com.abc.oa.services
com.abc.oa.entity
com.abc.oa.App 主程序对象
    
包名命名方法：
全部小写,公司网址倒写。
package com.baidu.wenku.ui;
package org.apache.commons.io;
abc.com
http://www.abc.com

package com.abc.oa.db;

5.3 extends类的继承

• 继承extends
  • 先执行父类，再执行子类

java类是单继承 ,java类不支持多继承。
class B{
}
class A extends B{
}
//final 类为最终类，没有子类，不能被extends继承

• 重载

// 重载 可以出现在一类中，也可以出现在继承关系。
public double square(double d) {
return d * d;
}

• 重写

//重写 覆盖 只能出现继承关系
public int square(int i) {
System.out.println("B....square(int i)");
return i * i;
}

final、extends

final 类没有类，final 属性为常量，final方法不能被子类重写

在没有继承的情况下，写不写this.都可以

调用父类的可以写上super.

public class TestAB {
    public static void main(String[] args) {
        C b = new C(3);
        System.out.println("------------");
        C b1 = new C(6);

        A a = new C(3);
        System.out.println("------------");
        a.square(3);
    }
}

public class A {
    public A(int i){
        System.out.println("父类构造A(int i)");
    }

    static {
        System.out.println("父类static{}");
    }

    {
        System.out.println("父类init{}");
    }
    public int square(int i){
        System.out.println("Parent...square(int i)");
        return i*i;
    }

}

public class B extends A {

    public B(int i){
        super(3);
        System.out.println("子类构造B(int i)");
    }

    // 重载 可以出现在一类中，也可以出现在继承关系。
    public double square(double d) {
        return d * d;
    }

    //重写 覆盖 只能出现继承关系
    public int square(int i) {
        System.out.println("B....square(int i)");
        return i * i;
//        return super.square(i);
    }

    public int getNum(int i){
        return super.square(i);//调用父类
//        return this.square(i);//调用子类
//        return square(i);//和上面相等  this.square=square 调用子类
    }

    static {
        System.out.println("子类static{}");
    }

    {
        System.out.println("子类init{}");
    }

    public static void main(String[] args) {
        B b = new B(3);
        System.out.println(b.square(3));
    }
}

5.4 abstract class抽象类

声明抽象类，使用关键字abstract

//内部匿名类
Db db = new Db(){
    
};

package cn.prictice2;

public class AbstractClassMain {
    public AbstractClass getAbstractClass() {
        return abstractClass;
    }

    public void setAbstractClass(AbstractClass abstractClass) {
        this.abstractClass = abstractClass;
    }

    public AbstractClassMain(AbstractClass abstractClass){
        this.abstractClass = abstractClass;
    }

    private AbstractClass abstractClass;

    public void connect(AbstractClass abstractClass){
       abstractClass.connection();
    }

    public static void main(String[] args) {
        AbstractClass d1 = new AbstractClassMySQL();
        AbstractClassMain dm = new AbstractClassMain(d1);
        //dm.connect(d1);
        dm.connect(new AbstractClassMySQL());
        dm.connect(new AbstractClassOracle());
    }
}

package cn.prictice2;

public class AbstractClassMySQL extends AbstractClass{
    @Override
    public void connection() {
        System.out.println("张三...MySQL conn...");
    }
}

package cn.prictice2;

public class AbstractClassOracle  extends AbstractClass{
    @Override
    public void connection() {
        System.out.println("李四...  Oracle conn...");
    }
}

package cn.prictice2;

public abstract class AbstractClass {
   //抽象方法
    public abstract void connection();

    public  int square(int i){
        return i*i;
    }

 //   public int sum(int a, int b){
 //       this.a = a;
 //       this.b = b;
 //       return a+b;
 //   }

 //   public static void main(String[] args) {

 //   }
}

抽象类：

1、抽象类声明时abstract class 类名{}

2、抽象类不能直接实例化，使用抽象类的子类

3、抽象类是可以有抽象方法 abstract void show(); 没有方法体

4、A a = new B();声明B类时继承了A类，A是父类，B是子类

5、抽象方法是不能私有的private修饰

6、有抽象方法的类必须抽象类，抽象类可有抽象方法，也可有普通方法，也可以没有抽象方

法

InputStream is = new FileInputStream();

InputStream 是抽象类，FileInputStream类是继承的子类

​ 类 = 静态段 初始化段 属性 方法 class 类名{}

抽象类 = 静态段 初始化段 属性 方法 [抽象方法] abstract class 类名{}

7、抽象更像一种编程规范，一般是项目经理，架构师编写的多。

问题讲解

User.builder().name().age().address();

@Builder

所有子类都会执行super()

1.构造方法

• 没有返回值，不能使用void

• 不能是static

• 方法名称必须和类名一致

• 如果编写类时没有写构造方法，编译器自动为class类文件添加一个无参构造方法

  • public Xxx(){
        super();
    }
    

• 如果编写构造方法，编译器不在添加无参构造，建议最好自己编写一个无参空构造方法

• 构造方法，不能通过对象调用，只能new的时候自动调用相关的构造方法。

• 构造方法中第一行，永远是调用父类构造器

  • //super();
    super(1,3);
    

1)了解多维数组，了解java.util.Arrays工具类使用

2)了解面向对象 类 对象 属性 方法？

3)掌握声明类，使用类，导入import 类，实例化对象。

4)掌握入口方法编写和执行，传参

5)掌握构造方法的编写

1.掌握继承

2.了解重载重写

3.了解抽象类 抽象方法

4.掌握extends final abstract super this 关键字使用

public Xxx(){
super();
}
```

• 如果编写构造方法，编译器不在添加无参构造，建议最好自己编写一个无参空构造方法

• 构造方法，不能通过对象调用，只能new的时候自动调用相关的构造方法。

• 构造方法中第一行，永远是调用父类构造器

  • //super();
    super(1,3);
    

1)了解多维数组，了解java.util.Arrays工具类使用

2)了解面向对象 类 对象 属性 方法？

3)掌握声明类，使用类，导入import 类，实例化对象。

4)掌握入口方法编写和执行，传参

5)掌握构造方法的编写

1.掌握继承

2.了解重载重写

3.了解抽象类 抽象方法

4.掌握extends final abstract super this 关键字使用